Turn gossip param

WORKSPACE

@@ -190,7 +190,7 @@ load("@rules_oci//oci:pull.bzl", "oci_pull")
 # A multi-arch base image
 oci_pull(
     name = "linux_debian11_multiarch_base",  # Debian bullseye
-    digest = "sha256:55a5e011b2c4246b4c51e01fcc2b452d151e03df052e357465f0392fcd59fddf",
+    digest = "sha256:b82f113425c5b5c714151aaacd8039bc141821cdcd3c65202d42bdf9c43ae60b",  # 2023-12-12
     image = "gcr.io/prysmaticlabs/distroless/cc-debian11",
     platforms = [
         "linux/amd64",
@@ -208,7 +208,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.24.6",
+    go_version = "1.24.0",
     nogo = "@//:nogo",
 )
 
@@ -253,16 +253,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.6.0-alpha.4"
+consensus_spec_version = "v1.6.0-alpha.1"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-MaN4zu3o0vWZypUHS5r4D8WzJF4wANoadM8qm6iyDs4=",
-        "minimal": "sha256-aZGNPp/bBvJgq3Wf6vyR0H6G3DOkbSuggEmOL4jEmtg=",
-        "mainnet": "sha256-C7jjosvpzUgw3GPajlsWBV02ZbkZ5Uv4ikmOqfDGajI=",
+        "general": "sha256-o4t9p3R+fQHF4KOykGmwlG3zDw5wUdVWprkzId8aIsk=",
+        "minimal": "sha256-sU7ToI8t3MR8x0vVjC8ERmAHZDWpEmnAC9FWIpHi5x4=",
+        "mainnet": "sha256-YKS4wngg0LgI9Upp4MYJ77aG+8+e/G4YeqEIlp06LZw=",
     },
     version = consensus_spec_version,
 )
@@ -278,7 +278,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-qreawRS77l8CebiNww8z727qUItw7KlHY1Xqj7IrPdk=",
+    integrity = "sha256-Nv4TEuEJPQIM4E6T9J0FOITsmappmXZjGtlhe1HEXnU=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/apiutil/BUILD.bazel

@@ -2,28 +2,18 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "common.go",
-        "header.go",
-    ],
+    srcs = ["common.go"],
     importpath = "github.com/OffchainLabs/prysm/v6/api/apiutil",
     visibility = ["//visibility:public"],
-    deps = [
-        "//consensus-types/primitives:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
+    deps = ["//consensus-types/primitives:go_default_library"],
 )
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "common_test.go",
-        "header_test.go",
-    ],
+    srcs = ["common_test.go"],
     embed = [":go_default_library"],
     deps = [
         "//consensus-types/primitives:go_default_library",
         "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
     ],
 )

api/apiutil/header.go

@@ -1,122 +0,0 @@
-package apiutil
-
-import (
-	"mime"
-	"sort"
-	"strconv"
-	"strings"
-
-	log "github.com/sirupsen/logrus"
-)
-
-type mediaRange struct {
-	mt   string  // canonicalised media‑type, e.g. "application/json"
-	q    float64 // quality factor (0‑1)
-	raw  string  // original string – useful for logging/debugging
-	spec int     // 2=exact, 1=type/*, 0=*/*
-}
-
-func parseMediaRange(field string) (mediaRange, bool) {
-	field = strings.TrimSpace(field)
-
-	mt, params, err := mime.ParseMediaType(field)
-	if err != nil {
-		log.WithError(err).Debug("Failed to parse header field")
-		return mediaRange{}, false
-	}
-
-	r := mediaRange{mt: mt, q: 1, spec: 2, raw: field}
-
-	if qs, ok := params["q"]; ok {
-		v, err := strconv.ParseFloat(qs, 64)
-		if err != nil || v < 0 || v > 1 {
-			log.WithField("q", qs).Debug("Invalid quality factor (0‑1)")
-			return mediaRange{}, false // skip invalid entry
-		}
-		r.q = v
-	}
-
-	switch {
-	case mt == "*/*":
-		r.spec = 0
-	case strings.HasSuffix(mt, "/*"):
-		r.spec = 1
-	}
-	return r, true
-}
-
-func hasExplicitQ(r mediaRange) bool {
-	return strings.Contains(strings.ToLower(r.raw), ";q=")
-}
-
-// ParseAccept returns media ranges sorted by q (desc) then specificity.
-func ParseAccept(header string) []mediaRange {
-	if header == "" {
-		return []mediaRange{{mt: "*/*", q: 1, spec: 0, raw: "*/*"}}
-	}
-
-	var out []mediaRange
-	for _, field := range strings.Split(header, ",") {
-		if r, ok := parseMediaRange(field); ok {
-			out = append(out, r)
-		}
-	}
-
-	sort.SliceStable(out, func(i, j int) bool {
-		ei, ej := hasExplicitQ(out[i]), hasExplicitQ(out[j])
-		if ei != ej {
-			return ei // explicit beats implicit
-		}
-		if out[i].q != out[j].q {
-			return out[i].q > out[j].q
-		}
-		return out[i].spec > out[j].spec
-	})
-	return out
-}
-
-// Matches reports whether content type is acceptable per the header.
-func Matches(header, ct string) bool {
-	for _, r := range ParseAccept(header) {
-		switch {
-		case r.q == 0:
-			continue
-		case r.mt == "*/*":
-			return true
-		case strings.HasSuffix(r.mt, "/*"):
-			if strings.HasPrefix(ct, r.mt[:len(r.mt)-1]) {
-				return true
-			}
-		case r.mt == ct:
-			return true
-		}
-	}
-	return false
-}
-
-// Negotiate selects the best server type according to the header.
-// Returns the chosen type and true, or "", false when nothing matches.
-func Negotiate(header string, serverTypes []string) (string, bool) {
-	for _, r := range ParseAccept(header) {
-		if r.q == 0 {
-			continue
-		}
-		for _, s := range serverTypes {
-			if Matches(r.mt, s) {
-				return s, true
-			}
-		}
-	}
-	return "", false
-}
-
-// PrimaryAcceptMatches only checks if the first accept matches
-func PrimaryAcceptMatches(header, produced string) bool {
-	for _, r := range ParseAccept(header) {
-		if r.q == 0 {
-			continue // explicitly unacceptable – skip
-		}
-		return Matches(r.mt, produced)
-	}
-	return false
-}

api/apiutil/header_test.go

@@ -1,174 +0,0 @@
-package apiutil
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestParseAccept(t *testing.T) {
-	type want struct {
-		mt   string
-		q    float64
-		spec int
-	}
-
-	cases := []struct {
-		name   string
-		header string
-		want   []want
-	}{
-		{
-			name:   "empty header becomes */*;q=1",
-			header: "",
-			want:   []want{{mt: "*/*", q: 1, spec: 0}},
-		},
-		{
-			name:   "quality ordering then specificity",
-			header: "application/json;q=0.2, */*;q=0.1, application/xml;q=0.5, text/*;q=0.5",
-			want: []want{
-				{mt: "application/xml", q: 0.5, spec: 2},
-				{mt: "text/*", q: 0.5, spec: 1},
-				{mt: "application/json", q: 0.2, spec: 2},
-				{mt: "*/*", q: 0.1, spec: 0},
-			},
-		},
-		{
-			name:   "invalid pieces are skipped",
-			header: "text/plain; q=boom, application/json",
-			want:   []want{{mt: "application/json", q: 1, spec: 2}},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := ParseAccept(tc.header)
-			gotProjected := make([]want, len(got))
-			for i, g := range got {
-				gotProjected[i] = want{mt: g.mt, q: g.q, spec: g.spec}
-			}
-			require.DeepEqual(t, gotProjected, tc.want)
-		})
-	}
-}
-
-func TestMatches(t *testing.T) {
-	cases := []struct {
-		name    string
-		accept  string
-		ct      string
-		matches bool
-	}{
-		{"exact match", "application/json", "application/json", true},
-		{"type wildcard", "application/*;q=0.8", "application/xml", true},
-		{"global wildcard", "*/*;q=0.1", "image/png", true},
-		{"explicitly unacceptable (q=0)", "text/*;q=0", "text/plain", false},
-		{"no match", "image/png", "application/json", false},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := Matches(tc.accept, tc.ct)
-			require.Equal(t, tc.matches, got)
-		})
-	}
-}
-
-func TestNegotiate(t *testing.T) {
-	cases := []struct {
-		name        string
-		accept      string
-		serverTypes []string
-		wantType    string
-		ok          bool
-	}{
-		{
-			name:        "highest quality wins",
-			accept:      "application/json;q=0.8,application/xml;q=0.9",
-			serverTypes: []string{"application/json", "application/xml"},
-			wantType:    "application/xml",
-			ok:          true,
-		},
-		{
-			name:        "wildcard matches first server type",
-			accept:      "*/*;q=0.5",
-			serverTypes: []string{"application/octet-stream", "application/json"},
-			wantType:    "application/octet-stream",
-			ok:          true,
-		},
-		{
-			name:        "no acceptable type",
-			accept:      "image/png",
-			serverTypes: []string{"application/json"},
-			wantType:    "",
-			ok:          false,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got, ok := Negotiate(tc.accept, tc.serverTypes)
-			require.Equal(t, tc.ok, ok)
-			require.Equal(t, tc.wantType, got)
-		})
-	}
-}
-
-func TestPrimaryAcceptMatches(t *testing.T) {
-	tests := []struct {
-		name     string
-		accept   string
-		produced string
-		expect   bool
-	}{
-		{
-			name:     "prefers json",
-			accept:   "application/json;q=0.9,application/xml",
-			produced: "application/json",
-			expect:   true,
-		},
-		{
-			name:     "wildcard application beats other wildcard",
-			accept:   "application/*;q=0.2,*/*;q=0.1",
-			produced: "application/xml",
-			expect:   true,
-		},
-		{
-			name:     "json wins",
-			accept:   "application/xml;q=0.8,application/json;q=0.9",
-			produced: "application/json",
-			expect:   true,
-		},
-		{
-			name:     "json loses",
-			accept:   "application/xml;q=0.8,application/json;q=0.9,application/octet-stream;q=0.99",
-			produced: "application/json",
-			expect:   false,
-		},
-		{
-			name:     "json wins with non q option",
-			accept:   "application/xml;q=0.8,image/png,application/json;q=0.9",
-			produced: "application/json",
-			expect:   true,
-		},
-		{
-			name:     "json not primary",
-			accept:   "image/png,application/json",
-			produced: "application/json",
-			expect:   false,
-		},
-		{
-			name:     "absent header",
-			accept:   "",
-			produced: "text/plain",
-			expect:   true,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := PrimaryAcceptMatches(tc.accept, tc.produced)
-			require.Equal(t, got, tc.expect)
-		})
-	}
-}

api/client/beacon/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//api/server/structs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

api/client/beacon/client.go

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

api/client/builder/client.go

@@ -102,7 +102,6 @@ type BuilderClient interface {
 	GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubkey [48]byte) (SignedBid, error)
 	RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error
 	SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, v1.BlobsBundler, error)
-	SubmitBlindedBlockPostFulu(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) error
 	Status(ctx context.Context) error
 }
 
@@ -153,8 +152,7 @@ func (c *Client) NodeURL() string {
 type reqOption func(*http.Request)
 
 // do is a generic, opinionated request function to reduce boilerplate amongst the methods in this package api/client/builder.
-// It validates that the HTTP response status matches the expectedStatus parameter.
-func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, expectedStatus int, opts ...reqOption) (res []byte, header http.Header, err error) {
+func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) (res []byte, header http.Header, err error) {
 	ctx, span := trace.StartSpan(ctx, "builder.client.do")
 	defer func() {
 		tracing.AnnotateError(span, err)
@@ -189,8 +187,8 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 			log.WithError(closeErr).Error("Failed to close response body")
 		}
 	}()
-	if r.StatusCode != expectedStatus {
-		err = unexpectedStatusErr(r, expectedStatus)
+	if r.StatusCode != http.StatusOK {
+		err = non200Err(r)
 		return
 	}
 	res, err = io.ReadAll(io.LimitReader(r.Body, client.MaxBodySize))
@@ -238,7 +236,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 			r.Header.Set("Accept", api.JsonMediaType)
 		}
 	}
-	data, header, err := c.do(ctx, http.MethodGet, path, nil, http.StatusOK, getOpts)
+	data, header, err := c.do(ctx, http.MethodGet, path, nil, getOpts)
 	if err != nil {
 		return nil, errors.Wrap(err, "error getting header from builder server")
 	}
@@ -411,7 +409,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 		}
 	}
 
-	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), http.StatusOK, postOpts); err != nil {
+	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), postOpts); err != nil {
 		return errors.Wrap(err, "do")
 	}
 	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
@@ -473,7 +471,7 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 
 	// post the blinded block - the execution payload response should contain the unblinded payload, along with the
 	// blobs bundle if it is post deneb.
-	data, header, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), http.StatusOK, postOpts)
+	data, header, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), postOpts)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
 	}
@@ -503,24 +501,6 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 	return ed, blobs, nil
 }
 
-// SubmitBlindedBlockPostFulu calls the builder API endpoint post-Fulu where relays only return status codes.
-// This method is used after the Fulu fork when MEV-boost relays no longer return execution payloads.
-func (c *Client) SubmitBlindedBlockPostFulu(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) error {
-	body, postOpts, err := c.buildBlindedBlockRequest(sb)
-	if err != nil {
-		return err
-	}
-
-	// Post the blinded block - the response should only contain a status code (no payload)
-	_, _, err = c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), http.StatusAccepted, postOpts)
-	if err != nil {
-		return errors.Wrap(err, "error posting the blinded block to the builder api post-Fulu")
-	}
-
-	// Success is indicated by no error (status 202)
-	return nil
-}
-
 func (c *Client) checkBlockVersion(respBytes []byte, header http.Header) (int, error) {
 	var versionHeader string
 	if c.sszEnabled {
@@ -677,11 +657,11 @@ func (c *Client) Status(ctx context.Context) error {
 	getOpts := func(r *http.Request) {
 		r.Header.Set("Accept", api.JsonMediaType)
 	}
-	_, _, err := c.do(ctx, http.MethodGet, getStatus, nil, http.StatusOK, getOpts)
+	_, _, err := c.do(ctx, http.MethodGet, getStatus, nil, getOpts)
 	return err
 }
 
-func unexpectedStatusErr(response *http.Response, expected int) error {
+func non200Err(response *http.Response) error {
 	bodyBytes, err := io.ReadAll(io.LimitReader(response.Body, client.MaxErrBodySize))
 	var errMessage ErrorMessage
 	var body string
@@ -690,7 +670,7 @@ func unexpectedStatusErr(response *http.Response, expected int) error {
 	} else {
 		body = "response body:\n" + string(bodyBytes)
 	}
-	msg := fmt.Sprintf("expected=%d, got=%d, url=%s, body=%s", expected, response.StatusCode, response.Request.URL, body)
+	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
 	switch response.StatusCode {
 	case http.StatusUnsupportedMediaType:
 		log.WithError(ErrUnsupportedMediaType).Debug(msg)

api/client/builder/client_test.go

@@ -1555,89 +1555,6 @@ func testSignedBlindedBeaconBlockElectra(t *testing.T) *eth.SignedBlindedBeaconB
 	}
 }
 
-func TestSubmitBlindedBlockPostFulu(t *testing.T) {
-	ctx := t.Context()
-
-	t.Run("success", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
-				// Post-Fulu: only return status code, no payload
-				return &http.Response{
-					StatusCode: http.StatusAccepted,
-					Body:       io.NopCloser(bytes.NewBufferString("")),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:      hc,
-			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		err = c.SubmitBlindedBlockPostFulu(ctx, sbbb)
-		require.NoError(t, err)
-	})
-
-	t.Run("success_ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "bellatrix", r.Header.Get(api.VersionHeader))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				// Post-Fulu: only return status code, no payload
-				return &http.Response{
-					StatusCode: http.StatusAccepted,
-					Body:       io.NopCloser(bytes.NewBufferString("")),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		err = c.SubmitBlindedBlockPostFulu(ctx, sbbb)
-		require.NoError(t, err)
-	})
-
-	t.Run("error_response", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
-				message := ErrorMessage{
-					Code:    400,
-					Message: "Bad Request",
-				}
-				resp, err := json.Marshal(message)
-				require.NoError(t, err)
-				return &http.Response{
-					StatusCode: http.StatusBadRequest,
-					Body:       io.NopCloser(bytes.NewBuffer(resp)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:      hc,
-			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		err = c.SubmitBlindedBlockPostFulu(ctx, sbbb)
-		require.ErrorIs(t, err, ErrNotOK)
-	})
-}
-
 func TestRequestLogger(t *testing.T) {
 	wo := WithObserver(&requestLogger{})
 	c, err := NewClient("localhost:3500", wo)
@@ -1810,7 +1727,7 @@ func TestSubmitBlindedBlock_BlobsBundlerInterface(t *testing.T) {
 	t.Run("Interface signature verification", func(t *testing.T) {
 		// This test verifies that the SubmitBlindedBlock method signature
 		// has been updated to return BlobsBundler interface
-
+		
 		client := &Client{}
 
 		// Verify the method exists with the correct signature

api/client/builder/testing/mock.go

@@ -45,11 +45,6 @@ func (MockClient) SubmitBlindedBlock(_ context.Context, _ interfaces.ReadOnlySig
 	return nil, nil, nil
 }
 
-// SubmitBlindedBlockPostFulu --
-func (MockClient) SubmitBlindedBlockPostFulu(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock) error {
-	return nil
-}
-
 // Status --
 func (MockClient) Status(_ context.Context) error {
 	return nil

api/client/builder/types_test.go

@@ -1699,7 +1699,7 @@ func TestExecutionPayloadHeaderCapellaRoundtrip(t *testing.T) {
 	require.DeepEqual(t, string(expected[0:len(expected)-1]), string(m))
 }
 
-func TestErrorMessage_unexpectedStatusErr(t *testing.T) {
+func TestErrorMessage_non200Err(t *testing.T) {
 	mockRequest := &http.Request{
 		URL: &url.URL{Path: "example.com"},
 	}
@@ -1779,7 +1779,7 @@ func TestErrorMessage_unexpectedStatusErr(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := unexpectedStatusErr(tt.args, http.StatusOK)
+			err := non200Err(tt.args)
 			if err != nil && tt.wantMessage != "" {
 				require.ErrorContains(t, tt.wantMessage, err)
 			}

api/server/middleware/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api:go_default_library",
-        "//api/apiutil:go_default_library",
         "@com_github_rs_cors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

api/server/middleware/middleware.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"github.com/OffchainLabs/prysm/v6/api"
-	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/rs/cors"
 	log "github.com/sirupsen/logrus"
 )
@@ -75,10 +74,42 @@ func ContentTypeHandler(acceptedMediaTypes []string) Middleware {
 func AcceptHeaderHandler(serverAcceptedTypes []string) Middleware {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if _, ok := apiutil.Negotiate(r.Header.Get("Accept"), serverAcceptedTypes); !ok {
-				http.Error(w, "Not Acceptable", http.StatusNotAcceptable)
+			acceptHeader := r.Header.Get("Accept")
+			// header is optional and should skip if not provided
+			if acceptHeader == "" {
+				next.ServeHTTP(w, r)
 				return
 			}
+
+			accepted := false
+			acceptTypes := strings.Split(acceptHeader, ",")
+			// follows rules defined in https://datatracker.ietf.org/doc/html/rfc2616#section-14.1
+			for _, acceptType := range acceptTypes {
+				acceptType = strings.TrimSpace(acceptType)
+				if acceptType == "*/*" {
+					accepted = true
+					break
+				}
+				for _, serverAcceptedType := range serverAcceptedTypes {
+					if strings.HasPrefix(acceptType, serverAcceptedType) {
+						accepted = true
+						break
+					}
+					if acceptType != "/*" && strings.HasSuffix(acceptType, "/*") && strings.HasPrefix(serverAcceptedType, acceptType[:len(acceptType)-2]) {
+						accepted = true
+						break
+					}
+				}
+				if accepted {
+					break
+				}
+			}
+
+			if !accepted {
+				http.Error(w, fmt.Sprintf("Not Acceptable: %s", acceptHeader), http.StatusNotAcceptable)
+				return
+			}
+
 			next.ServeHTTP(w, r)
 		})
 	}

api/server/structs/BUILD.bazel

@@ -36,7 +36,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//container/slice:go_default_library",
-        "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",

api/server/structs/conversions.go

@@ -10,7 +10,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/validator"
 	"github.com/OffchainLabs/prysm/v6/container/slice"
-	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/math"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
@@ -134,6 +133,66 @@ func SignedBLSChangesFromConsensus(src []*eth.SignedBLSToExecutionChange) []*Sig
 	return changes
 }
 
+func SignedInclusionListFromConsensus(src *eth.SignedInclusionList) *SignedInclusionList {
+	transactions := make([]string, len(src.Message.Transactions))
+	for i, transaction := range src.Message.Transactions {
+		transactions[i] = hexutil.Encode(transaction)
+	}
+
+	return &SignedInclusionList{
+		Message: &InclusionList{
+			Slot:                       fmt.Sprintf("%d", src.Message.Slot),
+			ValidatorIndex:             fmt.Sprintf("%d", src.Message.ValidatorIndex),
+			InclusionListCommitteeRoot: hexutil.Encode(src.Message.InclusionListCommitteeRoot),
+			Transactions:               transactions,
+		},
+		Signature: hexutil.Encode(src.Signature),
+	}
+}
+
+func (s *SignedInclusionList) ToConsensus() (*eth.SignedInclusionList, error) {
+	message, err := s.Message.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Message")
+	}
+	signature, err := bytesutil.DecodeHexWithLength(s.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+	return &eth.SignedInclusionList{
+		Message:   message,
+		Signature: signature,
+	}, nil
+}
+
+func (s *InclusionList) ToConsensus() (*eth.InclusionList, error) {
+	slot, err := strconv.ParseUint(s.Slot, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Slot")
+	}
+	validatorIndex, err := strconv.ParseUint(s.ValidatorIndex, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "ValidatorIndex")
+	}
+	inclusionListCommitteeRoot, err := bytesutil.DecodeHexWithLength(s.InclusionListCommitteeRoot, fieldparams.RootLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "InclusionListCommitteeRoot")
+	}
+	transactions := make([][]byte, len(s.Transactions))
+	for i, transaction := range s.Transactions {
+		transactions[i], err = bytesutil.DecodeHexWithMaxLength(transaction, fieldparams.MaxBytesPerTxLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Transactions[%d]", i))
+		}
+	}
+	return &eth.InclusionList{
+		Slot:                       primitives.Slot(slot),
+		ValidatorIndex:             primitives.ValidatorIndex(validatorIndex),
+		InclusionListCommitteeRoot: inclusionListCommitteeRoot,
+		Transactions:               transactions,
+	}, nil
+}
+
 func (s *Fork) ToConsensus() (*eth.Fork, error) {
 	previousVersion, err := bytesutil.DecodeHexWithLength(s.PreviousVersion, 4)
 	if err != nil {
@@ -700,11 +759,6 @@ func (m *SyncCommitteeMessage) ToConsensus() (*eth.SyncCommitteeMessage, error)
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Signature")
 	}
-	// Add validation to check if the signature is valid BLS format
-	_, err = bls.SignatureFromBytes(sig)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
 
 	return &eth.SyncCommitteeMessage{
 		Slot:           primitives.Slot(slot),

api/server/structs/endpoints_beacon.go

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

api/server/structs/endpoints_events.go

@@ -103,6 +103,11 @@ type BlobSidecarEvent struct {
 	VersionedHash string `json:"versioned_hash"`
 }
 
+type InclusionListEvent struct {
+	Version string               `json:"version"`
+	Data    *SignedInclusionList `json:"data"`
+}
+
 type LightClientFinalityUpdateEvent struct {
 	Version string                     `json:"version"`
 	Data    *LightClientFinalityUpdate `json:"data"`

api/server/structs/endpoints_node.go

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

api/server/structs/other.go

@@ -262,3 +262,15 @@ type PendingConsolidation struct {
 	SourceIndex string `json:"source_index"`
 	TargetIndex string `json:"target_index"`
 }
+
+type SignedInclusionList struct {
+	Message   *InclusionList `json:"message"`
+	Signature string         `json:"signature"`
+}
+
+type InclusionList struct {
+	Slot                       string   `json:"slot"`
+	ValidatorIndex             string   `json:"validator_index"`
+	InclusionListCommitteeRoot string   `json:"inclusion_list_committee_root"`
+	Transactions               []string `json:"transactions"`
+}

beacon-chain/blockchain/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "forkchoice_update_execution.go",
         "head.go",
         "head_sync_committee_info.go",
+        "inclusion_list.go",
         "init_sync_process_block.go",
         "log.go",
         "merge_ascii_art.go",
@@ -73,7 +74,6 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -182,7 +182,6 @@ go_test(
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -196,7 +195,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
-        "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -42,6 +42,7 @@ type ForkchoiceFetcher interface {
 	CachedHeadRoot() [32]byte
 	GetProposerHead() [32]byte
 	SetForkChoiceGenesisTime(time.Time)
+	GetAttesterHead() [32]byte
 	UpdateHead(context.Context, primitives.Slot)
 	HighestReceivedBlockSlot() primitives.Slot
 	ReceivedBlocksLastEpoch() (uint64, error)

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -27,6 +27,13 @@ func (s *Service) GetProposerHead() [32]byte {
 	return s.cfg.ForkChoiceStore.GetProposerHead()
 }
 
+// GetAttesterHead returns the corresponding value from forkchoice
+func (s *Service) GetAttesterHead() [32]byte {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.GetAttesterHead()
+}
+
 // SetForkChoiceGenesisTime sets the genesis time in Forkchoice
 func (s *Service) SetForkChoiceGenesisTime(timestamp time.Time) {
 	s.cfg.ForkChoiceStore.Lock()

beacon-chain/blockchain/chain_info_test.go

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

beacon-chain/blockchain/currently_syncing_block.go

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

beacon-chain/blockchain/error.go

@@ -44,8 +44,6 @@ var (
 	errMaxBlobsExceeded = verification.AsVerificationFailure(errors.New("expected commitments in block exceeds MAX_BLOBS_PER_BLOCK"))
 	// errMaxDataColumnsExceeded is returned when the number of data columns exceeds the maximum allowed.
 	errMaxDataColumnsExceeded = verification.AsVerificationFailure(errors.New("expected data columns for node exceeds NUMBER_OF_COLUMNS"))
-	// errBlockBeingSynced is returned when a block is being synced.
-	errBlockBeingSynced = errors.New("block is being synced")
 )
 
 // An invalid block is the block that fails state transition based on the core protocol rules.

beacon-chain/blockchain/execution_engine.go

@@ -174,7 +174,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 			"payloadID": fmt.Sprintf("%#x", bytesutil.Trunc(payloadID[:])),
 		}).Info("Forkchoice updated with payload attributes for proposal")
 		s.cfg.PayloadIDCache.Set(nextSlot, arg.headRoot, pId)
-		go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), arg.headBlock, arg.headRoot, nextSlot)
 	} else if hasAttr && payloadID == nil && !features.Get().PrepareAllPayloads {
 		log.WithFields(logrus.Fields{
 			"blockHash": fmt.Sprintf("%#x", headPayload.BlockHash()),
@@ -268,12 +267,25 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 			return false, errors.New("nil execution requests")
 		}
 	}
-	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests)
+
+	var txs [][]byte
+	// Post-FOCIL, only consider the inclusion list constraint if it matches the current slot.
+	if slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().Eip7805ForkEpoch && s.CurrentSlot() == blk.Block().Slot() {
+		txs = s.inclusionListCache.Get(blk.Block().Slot() - 1)
+	}
+	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests, txs)
 
 	switch {
 	case err == nil:
 		newPayloadValidNodeCount.Inc()
 		return true, nil
+	case errors.Is(err, execution.ErrBadInclusionListPayloadStatus):
+		log.WithFields(logrus.Fields{
+			"slot":       blk.Block().Slot(),
+			"parentRoot": fmt.Sprintf("%#x", parentRoot),
+		}).Info("Called new payload but inclusion list didn't satisfy")
+		blk.Block().MarkInclusionListNotSatisfied() // Cache the block root that fails to satisfy the inclusion list constraint.
+		return true, nil
 	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 		newPayloadOptimisticNodeCount.Inc()
 		log.WithFields(logrus.Fields{

beacon-chain/blockchain/execution_engine_test.go

@@ -19,7 +19,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	v1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -310,7 +309,6 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 		block: wba,
 	}
 
-	genesis.StoreStateDuringTest(t, st)
 	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
 	a := &fcuConfig{
@@ -405,7 +403,6 @@ func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 
 	bState, _ := util.DeterministicGenesisState(t, 10)
-	genesis.StoreStateDuringTest(t, bState)
 	require.NoError(t, beaconDB.SaveState(ctx, bState, bra))
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)

beacon-chain/blockchain/forkchoice_update_execution.go

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

beacon-chain/blockchain/inclusion_list.go

@@ -0,0 +1,72 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/sirupsen/logrus"
+)
+
+const updateInclusionListBlockInterval = time.Second
+
+// Routine that updates block building with inclusion lists one second before the slot starts.
+func (s *Service) updateBlockWithInclusionListRoutine() {
+	if err := s.waitForSync(); err != nil {
+		log.WithError(err).Error("Failed to wait for initial sync")
+		return
+	}
+
+	interval := time.Second*time.Duration(params.BeaconConfig().SecondsPerSlot) - updateInclusionListBlockInterval
+	ticker := slots.NewSlotTickerWithIntervals(s.genesisTime, []time.Duration{interval})
+
+	for {
+		select {
+		case <-s.ctx.Done():
+			return
+		case <-ticker.C():
+			s.updateBlockWithInclusionList(context.Background())
+		}
+	}
+}
+
+// Updates block building with inclusion lists, the current payload ID, and the new upload ID.
+func (s *Service) updateBlockWithInclusionList(ctx context.Context) {
+	currentSlot := s.CurrentSlot()
+
+	// Skip update if not in or past the FOCIL fork epoch.
+	if slots.ToEpoch(currentSlot) < params.BeaconConfig().Eip7805ForkEpoch {
+		return
+	}
+
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+
+	headRoot := s.headRoot()
+	id, found := s.cfg.PayloadIDCache.PayloadID(currentSlot+1, headRoot)
+	if !found {
+		return
+	}
+
+	txs := s.inclusionListCache.Get(currentSlot)
+	if len(txs) == 0 {
+		log.WithField("slot", currentSlot).Warn("No inclusion list transactions found to update block")
+		return
+	}
+
+	newID, err := s.cfg.ExecutionEngineCaller.UpdatePayloadWithInclusionList(ctx, id, txs)
+	if err != nil {
+		log.WithError(err).Error("Failed to update block with inclusion list")
+		return
+	}
+
+	log.WithFields(logrus.Fields{
+		"slot":     currentSlot,
+		"headRoot": fmt.Sprintf("%x", headRoot),
+		"txs":      len(txs),
+	}).Info("Updated block with inclusion list")
+
+	s.cfg.PayloadIDCache.Set(currentSlot+1, headRoot, *newID)
+}

beacon-chain/blockchain/kzg/trusted_setup.go

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

beacon-chain/blockchain/options.go

@@ -7,6 +7,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
@@ -35,7 +36,7 @@ func WithMaxGoroutines(x int) Option {
 // WithLCStore for light client store access.
 func WithLCStore() Option {
 	return func(s *Service) error {
-		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
+		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB)
 		return nil
 	}
 }
@@ -234,6 +235,14 @@ func WithSyncChecker(checker Checker) Option {
 	}
 }
 
+// WithCustodyInfo sets the custody info for the blockchain service.
+func WithCustodyInfo(custodyInfo *peerdas.CustodyInfo) Option {
+	return func(s *Service) error {
+		s.cfg.CustodyInfo = custodyInfo
+		return nil
+	}
+}
+
 // WithSlasherEnabled sets whether the slasher is enabled or not.
 func WithSlasherEnabled(enabled bool) Option {
 	return func(s *Service) error {
@@ -266,3 +275,10 @@ func WithStartWaitingDataColumnSidecars(c chan bool) Option {
 		return nil
 	}
 }
+
+func WithInclusionListCache(c *cache.InclusionLists) Option {
+	return func(s *Service) error {
+		s.inclusionListCache = c
+		return nil
+	}
+}

beacon-chain/blockchain/process_block.go

@@ -584,7 +584,7 @@ func (s *Service) runLateBlockTasks() {
 // It returns a map where each key represents a missing BlobSidecar index.
 // An empty map means we have all indices; a non-empty map can be used to compare incoming
 // BlobSidecars against the set of known missing sidecars.
-func missingBlobIndices(store *filesystem.BlobStorage, root [fieldparams.RootLength]byte, expected [][]byte, slot primitives.Slot) (map[uint64]bool, error) {
+func missingBlobIndices(bs *filesystem.BlobStorage, root [fieldparams.RootLength]byte, expected [][]byte, slot primitives.Slot) (map[uint64]bool, error) {
 	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	if len(expected) == 0 {
 		return nil, nil
@@ -592,7 +592,7 @@ func missingBlobIndices(store *filesystem.BlobStorage, root [fieldparams.RootLen
 	if len(expected) > maxBlobsPerBlock {
 		return nil, errMaxBlobsExceeded
 	}
-	indices := store.Summary(root)
+	indices := bs.Summary(root)
 	missing := make(map[uint64]bool, len(expected))
 	for i := range expected {
 		if len(expected[i]) > 0 && !indices.HasIndex(uint64(i)) {
@@ -607,7 +607,7 @@ func missingBlobIndices(store *filesystem.BlobStorage, root [fieldparams.RootLen
 // It returns a map where each key represents a missing DataColumnSidecar index.
 // An empty map means we have all indices; a non-empty map can be used to compare incoming
 // DataColumns against the set of known missing sidecars.
-func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldparams.RootLength]byte, expected map[uint64]bool) (map[uint64]bool, error) {
+func missingDataColumnIndices(bs *filesystem.DataColumnStorage, root [fieldparams.RootLength]byte, expected map[uint64]bool) (map[uint64]bool, error) {
 	if len(expected) == 0 {
 		return nil, nil
 	}
@@ -619,7 +619,7 @@ func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldpa
 	}
 
 	// Get a summary of the data columns stored in the database.
-	summary := store.Summary(root)
+	summary := bs.Summary(root)
 
 	// Check all expected data columns against the summary.
 	missing := make(map[uint64]bool)
@@ -666,11 +666,10 @@ func (s *Service) areDataColumnsAvailable(
 	root [fieldparams.RootLength]byte,
 	block interfaces.ReadOnlyBeaconBlock,
 ) error {
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
-
-	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
 	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
+
 	if !params.WithinDAPeriod(blockEpoch, currentEpoch) {
 		return nil
 	}
@@ -691,20 +690,16 @@ func (s *Service) areDataColumnsAvailable(
 	}
 
 	// All columns to sample need to be available for the block to be considered available.
+	// https://github.com/ethereum/consensus-specs/blob/v1.5.0-alpha.10/specs/fulu/das-core.md#custody-sampling
 	nodeID := s.cfg.P2P.NodeID()
 
+	// Prevent custody group count to change during the rest of the function.
+	s.cfg.CustodyInfo.Mut.RLock()
+	defer s.cfg.CustodyInfo.Mut.RUnlock()
+
 	// Get the custody group sampling size for the node.
-	custodyGroupCount, err := s.cfg.P2P.CustodyGroupCount()
-	if err != nil {
-		return errors.Wrap(err, "custody group count")
-	}
-
-	// Compute the sampling size.
-	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#custody-sampling
-	samplingSize := max(samplesPerSlot, custodyGroupCount)
-
-	// Get the peer info for the node.
-	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
+	custodyGroupSamplingSize := s.cfg.CustodyInfo.CustodyGroupSamplingSize(peerdas.Actual)
+	peerInfo, _, err := peerdas.Info(nodeID, custodyGroupSamplingSize)
 	if err != nil {
 		return errors.Wrap(err, "peer info")
 	}
@@ -717,7 +712,7 @@ func (s *Service) areDataColumnsAvailable(
 	summary := s.dataColumnStorage.Summary(root)
 	storedDataColumnsCount := summary.Count()
 
-	minimumColumnCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+	minimumColumnCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 
 	// As soon as we have enough data column sidecars, we can reconstruct the missing ones.
 	// We don't need to wait for the rest of the data columns to declare the block as available.
@@ -820,7 +815,7 @@ func (s *Service) areDataColumnsAvailable(
 				missingIndices = uint64MapToSortedSlice(missingMap)
 			}
 
-			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, missingIndices)
+			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndices)
 		}
 	}
 }

beacon-chain/blockchain/process_block_helpers.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"strings"
@@ -170,7 +171,15 @@ func (s *Service) processLightClientUpdate(cfg *postBlockProcessConfig) error {
 		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
 	}
 
-	update, err := lightclient.NewLightClientUpdateFromBeaconState(cfg.ctx, cfg.postState, cfg.roblock, attestedState, attestedBlock, finalizedBlock)
+	update, err := lightclient.NewLightClientUpdateFromBeaconState(
+		cfg.ctx,
+		s.CurrentSlot(),
+		cfg.postState,
+		cfg.roblock,
+		attestedState,
+		attestedBlock,
+		finalizedBlock,
+	)
 	if err != nil {
 		return errors.Wrapf(err, "could not create light client update")
 	}
@@ -197,7 +206,8 @@ func (s *Service) processLightClientFinalityUpdate(
 
 	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
 
-	if finalizedCheckpoint == nil {
+	// Check if the finalized checkpoint has changed
+	if finalizedCheckpoint == nil || bytes.Equal(finalizedCheckpoint.GetRoot(), postState.FinalizedCheckpoint().Root) {
 		return nil
 	}
 
@@ -211,18 +221,51 @@ func (s *Service) processLightClientFinalityUpdate(
 		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
 	}
 
-	newUpdate, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, postState, signed, attestedState, attestedBlock, finalizedBlock)
+	newUpdate, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
+		ctx,
+		postState.Slot(),
+		postState,
+		signed,
+		attestedState,
+		attestedBlock,
+		finalizedBlock,
+	)
 
 	if err != nil {
 		return errors.Wrap(err, "could not create light client finality update")
 	}
 
-	if !lightclient.IsBetterFinalityUpdate(newUpdate, s.lcStore.LastFinalityUpdate()) {
-		log.Debug("Skip saving light client finality update: current update is better")
-		return nil
-	}
+	lastUpdate := s.lcStore.LastFinalityUpdate()
+	if lastUpdate != nil {
+		// The finalized_header.beacon.lastUpdateSlot is greater than that of all previously forwarded finality_updates,
+		// or it matches the highest previously forwarded lastUpdateSlot and also has a sync_aggregate indicating supermajority (> 2/3)
+		// sync committee participation while the previously forwarded finality_update for that lastUpdateSlot did not indicate supermajority
+		newUpdateSlot := newUpdate.FinalizedHeader().Beacon().Slot
+		newHasSupermajority := lightclient.UpdateHasSupermajority(newUpdate.SyncAggregate())
 
-	s.lcStore.SetLastFinalityUpdate(newUpdate, true)
+		lastUpdateSlot := lastUpdate.FinalizedHeader().Beacon().Slot
+		lastHasSupermajority := lightclient.UpdateHasSupermajority(lastUpdate.SyncAggregate())
+
+		if newUpdateSlot < lastUpdateSlot {
+			log.Debug("Skip saving light client finality newUpdate: Older than local newUpdate")
+			return nil
+		}
+		if newUpdateSlot == lastUpdateSlot && (lastHasSupermajority || !newHasSupermajority) {
+			log.Debug("Skip saving light client finality update: No supermajority advantage")
+			return nil
+		}
+	}
+	log.Debug("Saving new light client finality update")
+	s.lcStore.SetLastFinalityUpdate(newUpdate)
+
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientFinalityUpdate,
+		Data: newUpdate,
+	})
+
+	if err = s.cfg.P2P.BroadcastLightClientFinalityUpdate(ctx, newUpdate); err != nil {
+		return errors.Wrap(err, "could not broadcast light client finality update")
+	}
 
 	return nil
 }
@@ -239,7 +282,14 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
 	}
 
-	newUpdate, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, postState, signed, attestedState, attestedBlock)
+	newUpdate, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
+		ctx,
+		postState.Slot(),
+		postState,
+		signed,
+		attestedState,
+		attestedBlock,
+	)
 
 	if err != nil {
 		if strings.Contains(err.Error(), lightclient.ErrNotEnoughSyncCommitteeBits) {
@@ -249,12 +299,26 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 		return errors.Wrap(err, "could not create light client optimistic update")
 	}
 
-	if !lightclient.IsBetterOptimisticUpdate(newUpdate, s.lcStore.LastOptimisticUpdate()) {
-		log.Debug("Skip saving light client optimistic update: current update is better")
-		return nil
+	lastUpdate := s.lcStore.LastOptimisticUpdate()
+	if lastUpdate != nil {
+		// The attested_header.beacon.slot is greater than that of all previously forwarded optimistic updates
+		if newUpdate.AttestedHeader().Beacon().Slot <= lastUpdate.AttestedHeader().Beacon().Slot {
+			log.Debug("Skip saving light client optimistic update: Older than local update")
+			return nil
+		}
 	}
 
-	s.lcStore.SetLastOptimisticUpdate(newUpdate, true)
+	log.Debug("Saving new light client optimistic update")
+	s.lcStore.SetLastOptimisticUpdate(newUpdate)
+
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: newUpdate,
+	})
+
+	if err = s.cfg.P2P.BroadcastLightClientOptimisticUpdate(ctx, newUpdate); err != nil {
+		return errors.Wrap(err, "could not broadcast light client optimistic update")
+	}
 
 	return nil
 }

beacon-chain/blockchain/process_block_test.go

@@ -35,7 +35,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -1981,15 +1980,14 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	genesisState, keys := util.DeterministicGenesisState(t, 64)
 	stateRoot, err := genesisState.HashTreeRoot(ctx)
 	require.NoError(t, err, "Could not hash genesis state")
-	gb := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(gb)
+	genesis := blocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
 	require.NoError(t, err)
-	genesisRoot, err := gb.Block.HashTreeRoot()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not get signing root")
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 
-	genesis.StoreStateDuringTest(t, genesisState)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot), "Could not save genesis state")
@@ -2889,13 +2887,14 @@ func TestIsDataAvailable(t *testing.T) {
 	})
 
 	t.Run("Fulu - more than half of the columns in custody", func(t *testing.T) {
-		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct)
 		for i := range minimumColumnsCountToReconstruct {
 			indices = append(indices, i)
 		}
 
 		params := testIsAvailableParams{
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
@@ -2908,6 +2907,7 @@ func TestIsDataAvailable(t *testing.T) {
 
 	t.Run("Fulu - no missing data columns", func(t *testing.T) {
 		params := testIsAvailableParams{
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave:           []uint64{1, 17, 19, 42, 75, 87, 102, 117, 119}, // 119 is not needed
 			blobKzgCommitmentsCount: 3,
 		}
@@ -2922,7 +2922,7 @@ func TestIsDataAvailable(t *testing.T) {
 		startWaiting := make(chan bool)
 
 		testParams := testIsAvailableParams{
-			options:       []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
 
 			blobKzgCommitmentsCount: 3,
@@ -2959,9 +2959,6 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
-		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
-		defer cancel()
-
 		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
@@ -2974,7 +2971,11 @@ func TestIsDataAvailable(t *testing.T) {
 
 		startWaiting := make(chan bool)
 
-		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+		var custodyInfo peerdas.CustodyInfo
+		custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(cgc)
+		custodyInfo.ToAdvertiseGroupCount.Set(cgc)
+
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct-missingColumns)
 
 		for i := range minimumColumnsCountToReconstruct - missingColumns {
@@ -2982,14 +2983,12 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		testParams := testIsAvailableParams{
-			options:                 []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithCustodyInfo(&custodyInfo), WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
-		_, _, err := service.cfg.P2P.UpdateCustodyInfo(0, cgc)
-		require.NoError(t, err)
 		block := signed.Block()
 		slot := block.Slot()
 		proposerIndex := block.ProposerIndex()
@@ -3021,9 +3020,6 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
-		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
-		defer cancel()
-
 		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
@@ -3032,7 +3028,7 @@ func TestIsDataAvailable(t *testing.T) {
 		startWaiting := make(chan bool)
 
 		params := testIsAvailableParams{
-			options:                 []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
 			blobKzgCommitmentsCount: 3,
 		}
 
@@ -3174,7 +3170,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
+				s.lcStore = &lightClient.Store{}
 
 				var oldActualUpdate interfaces.LightClientOptimisticUpdate
 				var err error
@@ -3183,7 +3179,14 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 					lOld, cfgOld := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.oldOptions...)
 					require.NoError(t, s.processLightClientOptimisticUpdate(cfgOld.ctx, cfgOld.roblock, cfgOld.postState))
 
-					oldActualUpdate, err = lightClient.NewLightClientOptimisticUpdateFromBeaconState(lOld.Ctx, lOld.State, lOld.Block, lOld.AttestedState, lOld.AttestedBlock)
+					oldActualUpdate, err = lightClient.NewLightClientOptimisticUpdateFromBeaconState(
+						lOld.Ctx,
+						lOld.State.Slot(),
+						lOld.State,
+						lOld.Block,
+						lOld.AttestedState,
+						lOld.AttestedBlock,
+					)
 					require.NoError(t, err)
 
 					// check that the old update is saved
@@ -3197,7 +3200,14 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 				lNew, cfgNew := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.newOptions...)
 				require.NoError(t, s.processLightClientOptimisticUpdate(cfgNew.ctx, cfgNew.roblock, cfgNew.postState))
 
-				newActualUpdate, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lNew.Ctx, lNew.State, lNew.Block, lNew.AttestedState, lNew.AttestedBlock)
+				newActualUpdate, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(
+					lNew.Ctx,
+					lNew.State.Slot(),
+					lNew.State,
+					lNew.Block,
+					lNew.AttestedState,
+					lNew.AttestedBlock,
+				)
 				require.NoError(t, err)
 
 				require.DeepNotEqual(t, newActualUpdate, oldActualUpdate, "new update should not be equal to old update")
@@ -3250,39 +3260,39 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 			expectReplace: true,
 		},
 		{
-			name:          "Old update is better - finalized slot is higher",
+			name:          "Old update is better - age - no supermajority",
 			oldOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1)},
 			newOptions:    []util.LightClientOption{},
 			expectReplace: false,
 		},
 		{
-			name:          "Old update is better - attested slot is higher",
-			oldOptions:    []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
+			name:          "Old update is better - age - both supermajority",
+			oldOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1), util.WithSupermajority()},
+			newOptions:    []util.LightClientOption{util.WithSupermajority()},
+			expectReplace: false,
+		},
+		{
+			name:          "Old update is better - supermajority",
+			oldOptions:    []util.LightClientOption{util.WithSupermajority()},
 			newOptions:    []util.LightClientOption{},
 			expectReplace: false,
 		},
 		{
-			name:          "Old update is better - signature slot is higher",
-			oldOptions:    []util.LightClientOption{util.WithIncreasedSignatureSlot(1)},
-			newOptions:    []util.LightClientOption{},
-			expectReplace: false,
-		},
-		{
-			name:          "New update is better - finalized slot is higher",
-			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
+			name:          "New update is better - age - both supermajority",
+			oldOptions:    []util.LightClientOption{util.WithSupermajority()},
+			newOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1), util.WithSupermajority()},
 			expectReplace: true,
 		},
 		{
-			name:          "New update is better - attested slot is higher",
+			name:          "New update is better - age - no supermajority",
 			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
+			newOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1)},
 			expectReplace: true,
 		},
 		{
-			name:          "New update is better - signature slot is higher",
+			name:          "New update is better - supermajority",
 			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithIncreasedSignatureSlot(1)},
+			newOptions:    []util.LightClientOption{util.WithSupermajority()},
 			expectReplace: true,
 		},
 	}
@@ -3314,7 +3324,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
+				s.lcStore = &lightClient.Store{}
 
 				var actualOldUpdate, actualNewUpdate interfaces.LightClientFinalityUpdate
 				var err error
@@ -3325,7 +3335,15 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 					require.NoError(t, s.processLightClientFinalityUpdate(cfgOld.ctx, cfgOld.roblock, cfgOld.postState))
 
 					// check that the old update is saved
-					actualOldUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(ctx, cfgOld.postState, cfgOld.roblock, lOld.AttestedState, lOld.AttestedBlock, lOld.FinalizedBlock)
+					actualOldUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(
+						ctx,
+						cfgOld.postState.Slot(),
+						cfgOld.postState,
+						cfgOld.roblock,
+						lOld.AttestedState,
+						lOld.AttestedBlock,
+						lOld.FinalizedBlock,
+					)
 					require.NoError(t, err)
 					oldUpdate := s.lcStore.LastFinalityUpdate()
 					require.DeepEqual(t, actualOldUpdate, oldUpdate)
@@ -3336,7 +3354,15 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 				require.NoError(t, s.processLightClientFinalityUpdate(cfgNew.ctx, cfgNew.roblock, cfgNew.postState))
 
 				// check that the actual old update and the actual new update are different
-				actualNewUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(ctx, cfgNew.postState, cfgNew.roblock, lNew.AttestedState, lNew.AttestedBlock, lNew.FinalizedBlock)
+				actualNewUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(
+					ctx,
+					cfgNew.postState.Slot(),
+					cfgNew.postState,
+					cfgNew.roblock,
+					lNew.AttestedState,
+					lNew.AttestedBlock,
+					lNew.FinalizedBlock,
+				)
 				require.NoError(t, err)
 				require.DeepNotEqual(t, actualOldUpdate, actualNewUpdate)
 

beacon-chain/blockchain/receive_attestation.go

@@ -108,6 +108,14 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 					s.cfg.ForkChoiceStore.Unlock()
 
 					s.UpdateHead(s.ctx, slotInterval.Slot)
+
+					// Prune inclusion list that's more than 1 epoch old.
+					// Mean at the second 0 of slot 100, we prune the inclusion list of slot 98.
+					cachedSlot := primitives.Slot(0)
+					if slotInterval.Slot > 2 {
+						cachedSlot = slotInterval.Slot - 2
+					}
+					s.inclusionListCache.Delete(cachedSlot)
 				}
 			}
 		}
@@ -177,7 +185,7 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 	for _, a := range atts {
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
-		// https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/fork-choice.md#validate_on_attestation
+		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
 		nextSlot := a.GetData().Slot + 1
 		if err := slots.VerifyTime(s.genesisTime, nextSlot, disparity); err != nil {
 			continue

beacon-chain/blockchain/receive_block.go

@@ -84,11 +84,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 
 	receivedTime := time.Now()
-	err := s.blockBeingSynced.set(blockRoot)
-	if errors.Is(err, errBlockBeingSynced) {
-		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring block currently being synced")
-		return nil
-	}
+	s.blockBeingSynced.set(blockRoot)
 	defer s.blockBeingSynced.unset(blockRoot)
 
 	blockCopy, err := block.Copy()

beacon-chain/blockchain/receive_block_test.go

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

beacon-chain/blockchain/receive_data_column.go

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

beacon-chain/blockchain/service.go

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

beacon-chain/blockchain/service_test.go

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

beacon-chain/blockchain/setup_test.go

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

beacon-chain/blockchain/testing/mock.go

@@ -640,6 +640,16 @@ func (s *ChainService) GetProposerHead() [32]byte {
 	return [32]byte{}
 }
 
+// GetAttesterHead mocks the same method in the chain service
+func (s *ChainService) GetAttesterHead() [32]byte {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.GetAttesterHead()
+	}
+	var rootArr [32]byte
+	copy(rootArr[:], s.Root)
+	return rootArr
+}
+
 // SetForkChoiceGenesisTime mocks the same method in the chain service
 func (s *ChainService) SetForkChoiceGenesisTime(timestamp time.Time) {
 	if s.ForkChoiceStore != nil {

beacon-chain/builder/service.go

@@ -25,7 +25,6 @@ var ErrNoBuilder = errors.New("builder endpoint not configured")
 // BlockBuilder defines the interface for interacting with the block builder
 type BlockBuilder interface {
 	SubmitBlindedBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, v1.BlobsBundler, error)
-	SubmitBlindedBlockPostFulu(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) error
 	GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubKey [48]byte) (builder.SignedBid, error)
 	RegisterValidator(ctx context.Context, reg []*ethpb.SignedValidatorRegistrationV1) error
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
@@ -102,22 +101,6 @@ func (s *Service) SubmitBlindedBlock(ctx context.Context, b interfaces.ReadOnlyS
 	return s.c.SubmitBlindedBlock(ctx, b)
 }
 
-// SubmitBlindedBlockPostFulu submits a blinded block to the builder relay network post-Fulu.
-// After Fulu, relays only return status codes (no payload).
-func (s *Service) SubmitBlindedBlockPostFulu(ctx context.Context, b interfaces.ReadOnlySignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "builder.SubmitBlindedBlockPostFulu")
-	defer span.End()
-	start := time.Now()
-	defer func() {
-		submitBlindedBlockLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-	if s.c == nil {
-		return ErrNoBuilder
-	}
-
-	return s.c.SubmitBlindedBlockPostFulu(ctx, b)
-}
-
 // GetHeader retrieves the header for a given slot and parent hash from the builder relay network.
 func (s *Service) GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubKey [48]byte) (builder.SignedBid, error) {
 	ctx, span := trace.StartSpan(ctx, "builder.GetHeader")

beacon-chain/builder/testing/mock.go

@@ -24,22 +24,21 @@ type Config struct {
 
 // MockBuilderService to mock builder.
 type MockBuilderService struct {
-	HasConfigured                 bool
-	Payload                       *v1.ExecutionPayload
-	PayloadCapella                *v1.ExecutionPayloadCapella
-	PayloadDeneb                  *v1.ExecutionPayloadDeneb
-	BlobBundle                    *v1.BlobsBundle
-	BlobBundleV2                  *v1.BlobsBundleV2
-	ErrSubmitBlindedBlock         error
-	ErrSubmitBlindedBlockPostFulu error
-	Bid                           *ethpb.SignedBuilderBid
-	BidCapella                    *ethpb.SignedBuilderBidCapella
-	BidDeneb                      *ethpb.SignedBuilderBidDeneb
-	BidElectra                    *ethpb.SignedBuilderBidElectra
-	RegistrationCache             *cache.RegistrationCache
-	ErrGetHeader                  error
-	ErrRegisterValidator          error
-	Cfg                           *Config
+	HasConfigured         bool
+	Payload               *v1.ExecutionPayload
+	PayloadCapella        *v1.ExecutionPayloadCapella
+	PayloadDeneb          *v1.ExecutionPayloadDeneb
+	BlobBundle            *v1.BlobsBundle
+	BlobBundleV2          *v1.BlobsBundleV2
+	ErrSubmitBlindedBlock error
+	Bid                   *ethpb.SignedBuilderBid
+	BidCapella            *ethpb.SignedBuilderBidCapella
+	BidDeneb              *ethpb.SignedBuilderBidDeneb
+	BidElectra            *ethpb.SignedBuilderBidElectra
+	RegistrationCache     *cache.RegistrationCache
+	ErrGetHeader          error
+	ErrRegisterValidator  error
+	Cfg                   *Config
 }
 
 // Configured for mocking.
@@ -116,8 +115,3 @@ func (s *MockBuilderService) RegistrationByValidatorID(ctx context.Context, id p
 func (s *MockBuilderService) RegisterValidator(context.Context, []*ethpb.SignedValidatorRegistrationV1) error {
 	return s.ErrRegisterValidator
 }
-
-// SubmitBlindedBlockPostFulu for mocking.
-func (s *MockBuilderService) SubmitBlindedBlockPostFulu(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock) error {
-	return s.ErrSubmitBlindedBlockPostFulu
-}

beacon-chain/cache/BUILD.bazel

@@ -15,6 +15,7 @@ go_library(
         "common.go",
         "doc.go",
         "error.go",
+        "inclusion_list.go",
         "interfaces.go",
         "payload_id.go",
         "proposer_indices.go",
@@ -75,6 +76,7 @@ go_test(
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
         "committee_test.go",
+        "inclusion_list_test.go",
         "payload_id_test.go",
         "private_access_test.go",
         "proposer_indices_test.go",

beacon-chain/cache/inclusion_list.go

@@ -0,0 +1,105 @@
+package cache
+
+import (
+	"crypto/sha256"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+)
+
+type InclusionLists struct {
+	mu  sync.RWMutex
+	ils map[primitives.Slot]map[primitives.ValidatorIndex]struct {
+		txs                    [][]byte
+		seenTwice              bool
+		isBeforeFreezeDeadline bool
+	}
+}
+
+// NewInclusionLists initializes a new InclusionLists instance.
+func NewInclusionLists() *InclusionLists {
+	return &InclusionLists{
+		ils: make(map[primitives.Slot]map[primitives.ValidatorIndex]struct {
+			txs                    [][]byte
+			seenTwice              bool
+			isBeforeFreezeDeadline bool
+		}),
+	}
+}
+
+// Add adds a set of transactions for a specific slot and validator index.
+func (i *InclusionLists) Add(slot primitives.Slot, validatorIndex primitives.ValidatorIndex, txs [][]byte, isBeforeFreezeDeadline bool) {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	if _, ok := i.ils[slot]; !ok {
+		i.ils[slot] = make(map[primitives.ValidatorIndex]struct {
+			txs                    [][]byte
+			seenTwice              bool
+			isBeforeFreezeDeadline bool
+		})
+	}
+
+	entry := i.ils[slot][validatorIndex]
+	if entry.seenTwice {
+		return // No need to modify if already marked as seen twice.
+	}
+
+	if entry.txs == nil {
+		entry.txs = txs
+		entry.isBeforeFreezeDeadline = isBeforeFreezeDeadline
+	} else {
+		entry.seenTwice = true
+		entry.txs = nil // Clear transactions to save space if seen twice.
+	}
+	i.ils[slot][validatorIndex] = entry
+}
+
+// Get retrieves unique transactions for a specific slot.
+func (i *InclusionLists) Get(slot primitives.Slot) [][]byte {
+	i.mu.RLock()
+	defer i.mu.RUnlock()
+
+	ils, exists := i.ils[slot]
+	if !exists {
+		return [][]byte{}
+	}
+
+	var uniqueTxs [][]byte
+	seen := make(map[[32]byte]struct{})
+	for _, entry := range ils {
+		if !entry.isBeforeFreezeDeadline {
+			continue
+		}
+		for _, tx := range entry.txs {
+			hash := sha256.Sum256(tx)
+			if _, duplicate := seen[hash]; !duplicate {
+				uniqueTxs = append(uniqueTxs, tx)
+				seen[hash] = struct{}{}
+			}
+		}
+	}
+	return uniqueTxs
+}
+
+// Delete removes all inclusion lists for a specific slot.
+func (i *InclusionLists) Delete(slot primitives.Slot) {
+	i.mu.Lock()
+	defer i.mu.Unlock()
+
+	delete(i.ils, slot)
+}
+
+// SeenTwice checks if a validator's transactions were marked as seen twice for a specific slot.
+func (i *InclusionLists) SeenTwice(slot primitives.Slot, idx primitives.ValidatorIndex) bool {
+	i.mu.RLock()
+	defer i.mu.RUnlock()
+
+	ils, exists := i.ils[slot]
+	if !exists {
+		return false
+	}
+
+	entry, exists := ils[idx]
+	return exists && entry.seenTwice
+}

beacon-chain/cache/inclusion_list_test.go

@@ -0,0 +1,81 @@
+package cache
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestInclusionLists(t *testing.T) {
+	il := NewInclusionLists()
+
+	tests := []struct {
+		name          string
+		actions       func()
+		expectedGet   [][]byte
+		expectedTwice bool
+	}{
+		{
+			name: "Add single validator with unique transactions",
+			actions: func() {
+				il.Add(1, 1, [][]byte{[]byte("tx1"), []byte("tx2")}, true)
+			},
+			expectedGet:   [][]byte{[]byte("tx1"), []byte("tx2")},
+			expectedTwice: false,
+		},
+		{
+			name: "Add duplicate transactions for second validator",
+			actions: func() {
+				il.Add(1, 2, [][]byte{[]byte("tx1"), []byte("tx3")}, true)
+			},
+			expectedGet:   [][]byte{[]byte("tx1"), []byte("tx2"), []byte("tx3")},
+			expectedTwice: false,
+		},
+		{
+			name: "Mark validator as seen twice",
+			actions: func() {
+				il.Add(1, 1, [][]byte{[]byte("tx4")}, true)
+			},
+			expectedGet:   [][]byte{[]byte("tx1"), []byte("tx3")},
+			expectedTwice: true,
+		},
+		{
+			name: "Delete a slot",
+			actions: func() {
+				il.Delete(1)
+			},
+			expectedGet:   nil,
+			expectedTwice: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.actions()
+
+			// Check Get results
+			got := il.Get(1)
+			if !compareTransactions(got, tt.expectedGet) {
+				t.Errorf("unexpected Get result: got %v, want %v", got, tt.expectedGet)
+			}
+
+			// Check SeenTwice result for validator 1
+			gotTwice := il.SeenTwice(1, 1)
+			if gotTwice != tt.expectedTwice {
+				t.Errorf("unexpected SeenTwice result: got %v, want %v", gotTwice, tt.expectedTwice)
+			}
+		})
+	}
+}
+
+// compareTransactions compares two slices of byte slices for equality.
+func compareTransactions(a, b [][]byte) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if !bytes.Equal(a[i], b[i]) {
+			return false
+		}
+	}
+	return true
+}

beacon-chain/core/blocks/BUILD.bazel

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

beacon-chain/core/blocks/signature.go

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

beacon-chain/core/electra/withdrawals.go

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

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

@@ -46,6 +46,9 @@ const (
 
 	// DataColumnReceived is sent after a data column has been seen after gossip validation rules.
 	DataColumnReceived = 12
+
+	// InclusionListReceived is sent after an inclusion list is received from gossip or rpc
+	InclusionListReceived = 13
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -82,6 +85,11 @@ type BlobSidecarReceivedData struct {
 	Blob *blocks.VerifiedROBlob
 }
 
+// InclusionListReceivedData is the data sent with InclusionListReceived events.
+type InclusionListReceivedData struct {
+	SignedInclusionList *ethpb.SignedInclusionList
+}
+
 // ProposerSlashingReceivedData is the data sent with ProposerSlashingReceived events.
 type ProposerSlashingReceivedData struct {
 	ProposerSlashing *ethpb.ProposerSlashing

beacon-chain/core/fulu/upgrade.go

@@ -15,7 +15,7 @@ import (
 )
 
 // UpgradeToFulu updates inputs a generic state to return the version Fulu state.
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/fork.md#upgrading-the-state
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/fork.md#upgrading-the-state
 func UpgradeToFulu(ctx context.Context, beaconState state.BeaconState) (state.BeaconState, error) {
 	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
 	if err != nil {

beacon-chain/core/helpers/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "beacon_committee.go",
         "block.go",
         "genesis.go",
+        "inclusion_list.go",
         "legacy.go",
         "metrics.go",
         "randao.go",
@@ -21,6 +22,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",

beacon-chain/core/helpers/beacon_committee.go

@@ -272,9 +272,10 @@ func BeaconCommittee(
 
 // CommitteeAssignment represents committee list, committee index, and to be attested slot for a given epoch.
 type CommitteeAssignment struct {
-	Committee      []primitives.ValidatorIndex
-	AttesterSlot   primitives.Slot
-	CommitteeIndex primitives.CommitteeIndex
+	Committee                  []primitives.ValidatorIndex
+	AttesterSlot               primitives.Slot
+	CommitteeIndex             primitives.CommitteeIndex
+	InclusionListCommitteeSlot primitives.Slot
 }
 
 // VerifyAssignmentEpoch verifies if the given epoch is valid for assignment based on the provided state.
@@ -445,6 +446,22 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 				assignments[vIndex].CommitteeIndex = primitives.CommitteeIndex(j)
 			}
 		}
+		if slots.ToEpoch(slot) >= params.BeaconConfig().Eip7805ForkEpoch {
+			// Retrieve inclusion list committee assignments for the slot and update the assignments map.
+			indices, err := GetInclusionListCommittee(ctx, state, slot)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get inclusion list committee")
+			}
+			for _, vIndex := range indices {
+				if _, exists := vals[vIndex]; !exists {
+					continue
+				}
+				if _, exists := assignments[vIndex]; !exists {
+					assignments[vIndex] = &CommitteeAssignment{}
+				}
+				assignments[vIndex].InclusionListCommitteeSlot = slot
+			}
+		}
 	}
 	return assignments, nil
 }

beacon-chain/core/helpers/inclusion_list.go

@@ -0,0 +1,107 @@
+package helpers
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/crypto/bls"
+	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/pkg/errors"
+)
+
+var (
+	errNilIl            = errors.New("nil inclusion list")
+	errNilCommitteeRoot = errors.New("nil inclusion list committee root")
+	errNilSignature     = errors.New("nil signature")
+	errIncorrectState   = errors.New("incorrect state version")
+)
+
+// ValidateNilSignedInclusionList validates that a SignedInclusionList is not nil and contains a signature.
+func ValidateNilSignedInclusionList(il *eth.SignedInclusionList) error {
+	if il == nil {
+		return errNilIl
+	}
+	if il.Signature == nil {
+		return errNilSignature
+	}
+	return ValidateNilInclusionList(il.Message)
+}
+
+// ValidateNilInclusionList validates that an InclusionList is not nil and contains a committee root.
+func ValidateNilInclusionList(il *eth.InclusionList) error {
+	if il == nil {
+		return errNilIl
+	}
+	if il.InclusionListCommitteeRoot == nil {
+		return errNilCommitteeRoot
+	}
+	return nil
+}
+
+// GetInclusionListCommittee retrieves the validator indices assigned to the inclusion list committee
+// for a given slot. Returns an error if the state or slot does not meet the required constraints.
+func GetInclusionListCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
+	if slots.ToEpoch(slot) < params.BeaconConfig().Eip7805ForkEpoch {
+		return nil, errIncorrectState
+	}
+	epoch := slots.ToEpoch(slot)
+	seed, err := Seed(state, epoch, params.BeaconConfig().DomainInclusionListCommittee)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get seed")
+	}
+	indices, err := ActiveValidatorIndices(ctx, state, epoch)
+	if err != nil {
+		return nil, err
+	}
+	start := uint64(slot%params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().InclusionListCommitteeSize
+	end := start + params.BeaconConfig().InclusionListCommitteeSize
+
+	shuffledIndices := make([]primitives.ValidatorIndex, len(indices))
+	copy(shuffledIndices, indices)
+	shuffledList, err := UnshuffleList(shuffledIndices, seed)
+	if err != nil {
+		return nil, err
+	}
+	return shuffledList[start:end], nil
+}
+
+// ValidateInclusionListSignature verifies the signature on a SignedInclusionList against the public key
+// of the validator specified in the inclusion list.
+func ValidateInclusionListSignature(ctx context.Context, st state.ReadOnlyBeaconState, il *eth.SignedInclusionList) error {
+	if err := ValidateNilSignedInclusionList(il); err != nil {
+		return err
+	}
+
+	val, err := st.ValidatorAtIndex(il.Message.ValidatorIndex)
+	if err != nil {
+		return err
+	}
+	pub, err := bls.PublicKeyFromBytes(val.PublicKey)
+	if err != nil {
+		return err
+	}
+	sig, err := bls.SignatureFromBytes(il.Signature)
+	if err != nil {
+		return err
+	}
+
+	currentEpoch := slots.ToEpoch(st.Slot())
+	domain, err := signing.Domain(st.Fork(), currentEpoch, params.BeaconConfig().DomainInclusionListCommittee, st.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+
+	root, err := signing.ComputeSigningRoot(il.Message, domain)
+	if err != nil {
+		return err
+	}
+
+	if !sig.Verify(pub, root[:]) {
+		return signing.ErrSigFailedToVerify
+	}
+	return nil
+}

beacon-chain/core/helpers/weak_subjectivity.go

@@ -206,9 +206,9 @@ func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Chec
 // MinEpochsForBlockRequests computes the number of epochs of block history that we need to maintain,
 // relative to the current epoch, per the p2p specs. This is used to compute the slot where backfill is complete.
 // value defined:
-// https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#configuration
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#configuration
 // MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2 (= 33024, ~5 months)
-// detailed rationale: https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
+// detailed rationale: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
 func MinEpochsForBlockRequests() primitives.Epoch {
 	return params.BeaconConfig().MinValidatorWithdrawabilityDelay +
 		primitives.Epoch(params.BeaconConfig().ChurnLimitQuotient/2)

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -292,7 +292,7 @@ func TestMinEpochsForBlockRequests(t *testing.T) {
 	params.SetActiveTestCleanup(t, params.MainnetConfig())
 	var expected primitives.Epoch = 33024
 	// expected value of 33024 via spec commentary:
-	// https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
+	// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
 	//	MIN_EPOCHS_FOR_BLOCK_REQUESTS is calculated using the arithmetic from compute_weak_subjectivity_period found in the weak subjectivity guide. Specifically to find this max epoch range, we use the worst case event of a very large validator size (>= MIN_PER_EPOCH_CHURN_LIMIT * CHURN_LIMIT_QUOTIENT).
 	//
 	//	MIN_EPOCHS_FOR_BLOCK_REQUESTS = (

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

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

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

@@ -26,12 +26,14 @@ const ErrNotEnoughSyncCommitteeBits = "sync committee bits count is less than re
 
 func NewLightClientFinalityUpdateFromBeaconState(
 	ctx context.Context,
+	currentSlot primitives.Slot,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientFinalityUpdate, error) {
-	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
+	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
+) (interfaces.LightClientFinalityUpdate, error) {
+	update, err := NewLightClientUpdateFromBeaconState(ctx, currentSlot, state, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -41,11 +43,13 @@ func NewLightClientFinalityUpdateFromBeaconState(
 
 func NewLightClientOptimisticUpdateFromBeaconState(
 	ctx context.Context,
+	currentSlot primitives.Slot,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
-	attestedBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientOptimisticUpdate, error) {
-	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, nil)
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
+) (interfaces.LightClientOptimisticUpdate, error) {
+	update, err := NewLightClientUpdateFromBeaconState(ctx, currentSlot, state, block, attestedState, attestedBlock, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -62,6 +66,7 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 //     if locally available (may be unavailable, e.g., when using checkpoint sync, or if it was pruned locally)
 func NewLightClientUpdateFromBeaconState(
 	ctx context.Context,
+	currentSlot primitives.Slot,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
@@ -516,7 +521,8 @@ func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
 func BlockToLightClientHeader(
 	ctx context.Context,
 	attestedBlockVersion int, // this is the version that the light client header should be in, based on the attested block.
-	block interfaces.ReadOnlySignedBeaconBlock, // this block is either the attested block, or the finalized block. in case of the latter, we might need to upgrade it to the attested block's version.
+	block interfaces.ReadOnlySignedBeaconBlock, // this block is either the attested block, or the finalized block.
+	// in case of the latter, we might need to upgrade it to the attested block's version.
 ) (interfaces.LightClientHeader, error) {
 	if block.Version() > attestedBlockVersion {
 		return nil, errors.Errorf("block version %s is greater than attested block version %s", version.String(block.Version()), version.String(attestedBlockVersion))
@@ -749,64 +755,3 @@ func UpdateHasSupermajority(syncAggregate *pb.SyncAggregate) bool {
 	numActiveParticipants := syncAggregate.SyncCommitteeBits.Count()
 	return numActiveParticipants*3 >= maxActiveParticipants*2
 }
-
-// IsFinalityUpdateValidForBroadcast checks if a finality update needs to be broadcasted.
-// It is also used to check if an incoming gossiped finality update is valid for forwarding and saving.
-func IsFinalityUpdateValidForBroadcast(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
-	if oldUpdate == nil {
-		return true
-	}
-	// The finalized_header.beacon.slot is greater than that of all previously forwarded finality_updates,
-	// or it matches the highest previously forwarded slot and also has a sync_aggregate indicating supermajority (> 2/3)
-	// sync committee participation while the previously forwarded finality_update for that slot did not indicate supermajority
-	newUpdateSlot := newUpdate.FinalizedHeader().Beacon().Slot
-	newHasSupermajority := UpdateHasSupermajority(newUpdate.SyncAggregate())
-
-	lastUpdateSlot := oldUpdate.FinalizedHeader().Beacon().Slot
-	lastHasSupermajority := UpdateHasSupermajority(oldUpdate.SyncAggregate())
-
-	if newUpdateSlot < lastUpdateSlot {
-		return false
-	}
-	if newUpdateSlot == lastUpdateSlot && (lastHasSupermajority || !newHasSupermajority) {
-		return false
-	}
-	return true
-}
-
-// IsBetterFinalityUpdate checks if the new finality update is better than the old one for saving.
-// This does not concern broadcasting, but rather the decision of whether to save the new update.
-// For broadcasting checks, use IsFinalityUpdateValidForBroadcast.
-func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
-	if oldUpdate == nil {
-		return true
-	}
-
-	// Full nodes SHOULD provide the LightClientFinalityUpdate with the highest attested_header.beacon.slot (if multiple, highest signature_slot)
-	newFinalizedSlot := newUpdate.FinalizedHeader().Beacon().Slot
-	newAttestedSlot := newUpdate.AttestedHeader().Beacon().Slot
-
-	oldFinalizedSlot := oldUpdate.FinalizedHeader().Beacon().Slot
-	oldAttestedSlot := oldUpdate.AttestedHeader().Beacon().Slot
-
-	if newFinalizedSlot < oldFinalizedSlot {
-		return false
-	}
-	if newFinalizedSlot == oldFinalizedSlot {
-		if newAttestedSlot < oldAttestedSlot {
-			return false
-		}
-		if newAttestedSlot == oldAttestedSlot && newUpdate.SignatureSlot() <= oldUpdate.SignatureSlot() {
-			return false
-		}
-	}
-	return true
-}
-
-func IsBetterOptimisticUpdate(newUpdate, oldUpdate interfaces.LightClientOptimisticUpdate) bool {
-	if oldUpdate == nil {
-		return true
-	}
-	// The attested_header.beacon.slot is greater than that of all previously forwarded optimistic updates
-	return newUpdate.AttestedHeader().Beacon().Slot > oldUpdate.AttestedHeader().Beacon().Slot
-}

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

@@ -34,7 +34,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Altair", func(t *testing.T) {
 		l := util.NewTestLightClient(t, version.Altair)
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
 		require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot(), "Signature slot is not equal")
@@ -46,7 +46,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Capella", func(t *testing.T) {
 		l := util.NewTestLightClient(t, version.Capella)
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
 
@@ -59,7 +59,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Deneb", func(t *testing.T) {
 		l := util.NewTestLightClient(t, version.Deneb)
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
 
@@ -72,7 +72,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Electra", func(t *testing.T) {
 		l := util.NewTestLightClient(t, version.Electra)
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
 
@@ -97,7 +97,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 		l := util.NewTestLightClient(t, version.Altair)
 
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -132,7 +132,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Capella)
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -206,7 +206,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 
 		t.Run("FinalizedBlock In Previous Fork", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Capella, util.WithFinalizedCheckpointInPrevFork())
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -240,7 +240,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Deneb)
 
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -315,7 +315,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 		t.Run("FinalizedBlock In Previous Fork", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Deneb, util.WithFinalizedCheckpointInPrevFork())
 
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -392,7 +392,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Electra)
 
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -467,7 +467,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 		t.Run("FinalizedBlock In Previous Fork", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Electra, util.WithFinalizedCheckpointInPrevFork())
 
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 

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

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

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

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

beacon-chain/core/peerdas/BUILD.bazel

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

beacon-chain/core/peerdas/das_core.go

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

beacon-chain/core/peerdas/das_core_test.go

@@ -17,8 +17,8 @@ func TestCustodyGroups(t *testing.T) {
 	// --------------------------------------------
 	// The happy path is unit tested in spec tests.
 	// --------------------------------------------
-	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
-	_, err := peerdas.CustodyGroups(enode.ID{}, numberOfCustodyGroups+1)
+	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
+	_, err := peerdas.CustodyGroups(enode.ID{}, numberOfCustodyGroup+1)
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupCountTooLarge)
 }
 
@@ -26,8 +26,8 @@ func TestComputeColumnsForCustodyGroup(t *testing.T) {
 	// --------------------------------------------
 	// The happy path is unit tested in spec tests.
 	// --------------------------------------------
-	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
-	_, err := peerdas.ComputeColumnsForCustodyGroup(numberOfCustodyGroups)
+	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
+	_, err := peerdas.ComputeColumnsForCustodyGroup(numberOfCustodyGroup)
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupTooLarge)
 }
 
@@ -67,55 +67,6 @@ func TestDataColumnSidecars(t *testing.T) {
 		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
 		require.ErrorIs(t, err, peerdas.ErrSizeMismatch)
 	})
-
-	t.Run("cells array too short for column index", func(t *testing.T) {
-		// Create a Fulu block with a blob commitment.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with insufficient cells for the number of columns.
-		// This simulates a scenario where cellsAndProofs has fewer cells than expected columns.
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, 10),  // Only 10 cells
-				Proofs: make([]kzg.Proof, 10), // Only 10 proofs
-			},
-		}
-
-		// This should fail because the function will try to access columns up to NumberOfColumns
-		// but we only have 10 cells/proofs.
-		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-		require.ErrorContains(t, "column index", err)
-		require.ErrorContains(t, "exceeds cells length", err)
-	})
-
-	t.Run("proofs array too short for column index", func(t *testing.T) {
-		// Create a Fulu block with a blob commitment.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with sufficient cells but insufficient proofs.
-		numberOfColumns := params.BeaconConfig().NumberOfColumns
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, numberOfColumns),
-				Proofs: make([]kzg.Proof, 5), // Only 5 proofs, less than columns
-			},
-		}
-
-		// This should fail when trying to access proof beyond index 4.
-		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-		require.ErrorContains(t, "column index", err)
-		require.ErrorContains(t, "exceeds proofs length", err)
-	})
 }
 
 func TestComputeCustodyGroupForColumn(t *testing.T) {
@@ -153,6 +104,62 @@ func TestComputeCustodyGroupForColumn(t *testing.T) {
 	})
 }
 
+func TestCustodyGroupSamplingSize(t *testing.T) {
+	testCases := []struct {
+		name                         string
+		custodyType                  peerdas.CustodyType
+		validatorsCustodyRequirement uint64
+		toAdvertiseCustodyGroupCount uint64
+		expected                     uint64
+	}{
+		{
+			name:                         "target, lower than samples per slot",
+			custodyType:                  peerdas.Target,
+			validatorsCustodyRequirement: 2,
+			expected:                     8,
+		},
+		{
+			name:                         "target, higher than samples per slot",
+			custodyType:                  peerdas.Target,
+			validatorsCustodyRequirement: 100,
+			expected:                     100,
+		},
+		{
+			name:                         "actual, lower than samples per slot",
+			custodyType:                  peerdas.Actual,
+			validatorsCustodyRequirement: 3,
+			toAdvertiseCustodyGroupCount: 4,
+			expected:                     8,
+		},
+		{
+			name:                         "actual, higher than samples per slot",
+			custodyType:                  peerdas.Actual,
+			validatorsCustodyRequirement: 100,
+			toAdvertiseCustodyGroupCount: 101,
+			expected:                     100,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create a custody info.
+			custodyInfo := peerdas.CustodyInfo{}
+
+			// Set the validators custody requirement for target custody group count.
+			custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(tc.validatorsCustodyRequirement)
+
+			// Set the to advertise custody group count.
+			custodyInfo.ToAdvertiseGroupCount.Set(tc.toAdvertiseCustodyGroupCount)
+
+			// Compute the custody group sampling size.
+			actual := custodyInfo.CustodyGroupSamplingSize(tc.custodyType)
+
+			// Check the result.
+			require.Equal(t, tc.expected, actual)
+		})
+	}
+}
+
 func TestCustodyColumns(t *testing.T) {
 	t.Run("group too large", func(t *testing.T) {
 		_, err := peerdas.CustodyColumns([]uint64{1_000_000})

beacon-chain/core/peerdas/info.go

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

beacon-chain/core/peerdas/info_test.go

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

beacon-chain/core/peerdas/p2p_interface.go

@@ -10,7 +10,10 @@ import (
 	"github.com/pkg/errors"
 )
 
-const kzgPosition = 11 // The index of the KZG commitment list in the Body
+const (
+	CustodyGroupCountEnrKey = "cgc"
+	kzgPosition             = 11 // The index of the KZG commitment list in the Body
+)
 
 var (
 	ErrIndexTooLarge               = errors.New("column index is larger than the specified columns count")
@@ -24,13 +27,13 @@ var (
 	ErrCannotLoadCustodyGroupCount = errors.New("cannot load the custody group count from peer")
 )
 
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#custody-group-count
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#custody-group-count
 type Cgc uint64
 
-func (Cgc) ENRKey() string { return params.BeaconNetworkConfig().CustodyGroupCountKey }
+func (Cgc) ENRKey() string { return CustodyGroupCountEnrKey }
 
 // VerifyDataColumnSidecar verifies if the data column sidecar is valid.
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#verify_data_column_sidecar
 func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 	// The sidecar index must be within the valid range.
 	numberOfColumns := params.BeaconConfig().NumberOfColumns
@@ -57,7 +60,7 @@ func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 // 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.
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
 func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
 	// Compute the total count.
 	count := 0
@@ -93,7 +96,7 @@ func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
 }
 
 // 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
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/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
@@ -125,7 +128,7 @@ func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
 }
 
 // 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
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#compute_subnet_for_data_column_sidecar
 func ComputeSubnetForDataColumnSidecar(columnIndex uint64) uint64 {
 	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
 	return columnIndex % dataColumnSidecarSubnetCount

beacon-chain/core/peerdas/reconstruction.go

@@ -18,8 +18,8 @@ var (
 	ErrBlobsCellsProofsMismatch = errors.New("blobs and cells proofs mismatch")
 )
 
-// MinimumColumnCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
-func MinimumColumnCountToReconstruct() uint64 {
+// MinimumColumnsCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
+func MinimumColumnsCountToReconstruct() uint64 {
 	// If the number of columns is odd, then we need total / 2 + 1 columns to reconstruct.
 	// If the number of columns is even, then we need total / 2 columns to reconstruct.
 	return (params.BeaconConfig().NumberOfColumns + 1) / 2
@@ -58,7 +58,7 @@ func ReconstructDataColumnSidecars(inVerifiedRoSidecars []blocks.VerifiedRODataC
 
 	// Check if there is enough sidecars to reconstruct the missing columns.
 	sidecarCount := len(sidecarByIndex)
-	if uint64(sidecarCount) < MinimumColumnCountToReconstruct() {
+	if uint64(sidecarCount) < MinimumColumnsCountToReconstruct() {
 		return nil, ErrNotEnoughDataColumnSidecars
 	}
 
@@ -123,7 +123,7 @@ func ReconstructDataColumnSidecars(inVerifiedRoSidecars []blocks.VerifiedRODataC
 
 // ConstructDataColumnSidecars constructs data column sidecars from a block, (un-extended) blobs and
 // cell proofs corresponding the extended blobs. The main purpose of this function is to
-// construct data column sidecars from data obtained from the execution client via:
+// construct data columns sidecars from data obtained from the execution client via:
 // - `engine_getBlobsV2` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getblobsv2, or
 // - `engine_getPayloadV5` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getpayloadv5
 // Note: In this function, to stick with the `BlobsBundleV2` format returned by the execution client in `engine_getPayloadV5`,
@@ -222,8 +222,8 @@ func ReconstructBlobs(block blocks.ROBlock, verifiedDataColumnSidecars []blocks.
 	// Check if the data column sidecars are aligned with the block.
 	dataColumnSidecars := make([]blocks.RODataColumn, 0, len(verifiedDataColumnSidecars))
 	for _, verifiedDataColumnSidecar := range verifiedDataColumnSidecars {
-		dataColumnSidecar := verifiedDataColumnSidecar.RODataColumn
-		dataColumnSidecars = append(dataColumnSidecars, dataColumnSidecar)
+		dataColumnSicecar := verifiedDataColumnSidecar.RODataColumn
+		dataColumnSidecars = append(dataColumnSidecars, dataColumnSicecar)
 	}
 
 	if err := DataColumnsAlignWithBlock(block, dataColumnSidecars); err != nil {
@@ -241,7 +241,7 @@ func ReconstructBlobs(block blocks.ROBlock, verifiedDataColumnSidecars []blocks.
 		return blobSidecars, nil
 	}
 
-	// We need to reconstruct the data column sidecars.
+	// We need to reconstruct the blobs.
 	reconstructedDataColumnSidecars, err := ReconstructDataColumnSidecars(verifiedDataColumnSidecars)
 	if err != nil {
 		return nil, errors.Wrap(err, "reconstruct data column sidecars")

beacon-chain/core/peerdas/reconstruction_test.go

@@ -48,7 +48,7 @@ func TestMinimumColumnsCountToReconstruct(t *testing.T) {
 			params.OverrideBeaconConfig(cfg)
 
 			// Compute the minimum number of columns needed to reconstruct.
-			actual := peerdas.MinimumColumnCountToReconstruct()
+			actual := peerdas.MinimumColumnsCountToReconstruct()
 			require.Equal(t, tc.expected, actual)
 		})
 	}
@@ -100,7 +100,7 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 	t.Run("not enough columns to enable reconstruction", func(t *testing.T) {
 		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
 
-		minimum := peerdas.MinimumColumnCountToReconstruct()
+		minimum := peerdas.MinimumColumnsCountToReconstruct()
 		_, err := peerdas.ReconstructDataColumnSidecars(verifiedRoSidecars[:minimum-1])
 		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
 	})
@@ -196,26 +196,6 @@ func TestReconstructBlobs(t *testing.T) {
 		require.ErrorIs(t, err, peerdas.ErrDataColumnSidecarsNotSortedByIndex)
 	})
 
-	t.Run("consecutive duplicates", func(t *testing.T) {
-		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
-
-		// [0, 1, 1, 3, 4, ...]
-		verifiedRoSidecars[2] = verifiedRoSidecars[1]
-
-		_, err := peerdas.ReconstructBlobs(emptyBlock, verifiedRoSidecars, []int{0})
-		require.ErrorIs(t, err, peerdas.ErrDataColumnSidecarsNotSortedByIndex)
-	})
-
-	t.Run("non-consecutive duplicates", func(t *testing.T) {
-		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
-
-		// [0, 1, 2, 1, 4, ...]
-		verifiedRoSidecars[3] = verifiedRoSidecars[1]
-
-		_, err := peerdas.ReconstructBlobs(emptyBlock, verifiedRoSidecars, []int{0})
-		require.ErrorIs(t, err, peerdas.ErrDataColumnSidecarsNotSortedByIndex)
-	})
-
 	t.Run("not enough columns", func(t *testing.T) {
 		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
 

beacon-chain/core/peerdas/validator.go

@@ -8,7 +8,7 @@ import (
 )
 
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/validator.md#validator-custody
 func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
 	totalNodeBalance := uint64(0)
 	for index := range validatorsIndex {
@@ -21,10 +21,10 @@ func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validat
 	}
 
 	beaconConfig := params.BeaconConfig()
-	numberOfCustodyGroups := beaconConfig.NumberOfCustodyGroups
+	numberOfCustodyGroup := beaconConfig.NumberOfCustodyGroups
 	validatorCustodyRequirement := beaconConfig.ValidatorCustodyRequirement
 	balancePerAdditionalCustodyGroup := beaconConfig.BalancePerAdditionalCustodyGroup
 
 	count := totalNodeBalance / balancePerAdditionalCustodyGroup
-	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroups), nil
+	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroup), nil
 }

beacon-chain/core/signing/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "domain.go",
+        "signature.go",
         "signing_root.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing",
@@ -24,6 +25,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "domain_test.go",
+        "signature_test.go",
         "signing_root_test.go",
     ],
     embed = [":go_default_library"],

beacon-chain/core/signing/signature.go

@@ -0,0 +1,34 @@
+package signing
+
+import (
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/pkg/errors"
+)
+
+var ErrNilRegistration = errors.New("nil signed registration")
+
+// VerifyRegistrationSignature verifies the signature of a validator's registration.
+func VerifyRegistrationSignature(
+	sr *ethpb.SignedValidatorRegistrationV1,
+) error {
+	if sr == nil || sr.Message == nil {
+		return ErrNilRegistration
+	}
+
+	d := params.BeaconConfig().DomainApplicationBuilder
+	// Per spec, we want the fork version and genesis validator to be nil.
+	// Which is genesis value and zero by default.
+	sd, err := ComputeDomain(
+		d,
+		nil, /* fork version */
+		nil /* genesis val root */)
+	if err != nil {
+		return err
+	}
+
+	if err := VerifySigningRoot(sr.Message, sr.Message.Pubkey, sr.Signature, sd); err != nil {
+		return ErrSigFailedToVerify
+	}
+	return nil
+}

beacon-chain/core/signing/signature_test.go

@@ -0,0 +1,42 @@
+package signing_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/crypto/bls"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestVerifyRegistrationSignature(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	reg := &ethpb.ValidatorRegistrationV1{
+		FeeRecipient: bytesutil.PadTo([]byte("fee"), 20),
+		GasLimit:     123456,
+		Timestamp:    uint64(time.Now().Unix()),
+		Pubkey:       sk.PublicKey().Marshal(),
+	}
+	d := params.BeaconConfig().DomainApplicationBuilder
+	domain, err := signing.ComputeDomain(d, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(reg, domain)
+	require.NoError(t, err)
+	sk.Sign(sr[:]).Marshal()
+
+	sReg := &ethpb.SignedValidatorRegistrationV1{
+		Message:   reg,
+		Signature: sk.Sign(sr[:]).Marshal(),
+	}
+	require.NoError(t, signing.VerifyRegistrationSignature(sReg))
+
+	sReg.Signature = []byte("bad")
+	require.ErrorIs(t, signing.VerifyRegistrationSignature(sReg), signing.ErrSigFailedToVerify)
+
+	sReg.Message = nil
+	require.ErrorIs(t, signing.VerifyRegistrationSignature(sReg), signing.ErrNilRegistration)
+}

beacon-chain/das/BUILD.bazel

@@ -39,8 +39,10 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/das/availability_columns.go

@@ -22,8 +22,8 @@ type LazilyPersistentStoreColumn struct {
 	store                  *filesystem.DataColumnStorage
 	nodeID                 enode.ID
 	cache                  *dataColumnCache
+	custodyInfo            *peerdas.CustodyInfo
 	newDataColumnsVerifier verification.NewDataColumnsVerifier
-	custodyGroupCount      uint64
 }
 
 var _ AvailabilityStore = &LazilyPersistentStoreColumn{}
@@ -38,18 +38,13 @@ type DataColumnsVerifier interface {
 
 // NewLazilyPersistentStoreColumn creates a new LazilyPersistentStoreColumn.
 // WARNING: The resulting LazilyPersistentStoreColumn is NOT thread-safe.
-func NewLazilyPersistentStoreColumn(
-	store *filesystem.DataColumnStorage,
-	nodeID enode.ID,
-	newDataColumnsVerifier verification.NewDataColumnsVerifier,
-	custodyGroupCount uint64,
-) *LazilyPersistentStoreColumn {
+func NewLazilyPersistentStoreColumn(store *filesystem.DataColumnStorage, nodeID enode.ID, newDataColumnsVerifier verification.NewDataColumnsVerifier, custodyInfo *peerdas.CustodyInfo) *LazilyPersistentStoreColumn {
 	return &LazilyPersistentStoreColumn{
 		store:                  store,
 		nodeID:                 nodeID,
 		cache:                  newDataColumnCache(),
+		custodyInfo:            custodyInfo,
 		newDataColumnsVerifier: newDataColumnsVerifier,
-		custodyGroupCount:      custodyGroupCount,
 	}
 }
 
@@ -131,11 +126,11 @@ func (s *LazilyPersistentStoreColumn) IsDataAvailable(ctx context.Context, curre
 		return errors.Wrap(err, "entry filter")
 	}
 
-	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#datacolumnsidecarsbyrange-v1
+	// https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/p2p-interface.md#datacolumnsidecarsbyrange-v1
 	verifier := s.newDataColumnsVerifier(roDataColumns, verification.ByRangeRequestDataColumnSidecarRequirements)
 
 	if err := verifier.ValidFields(); err != nil {
-		return errors.Wrap(err, "valid fields")
+		return errors.Wrap(err, "valid")
 	}
 
 	if err := verifier.SidecarInclusionProven(); err != nil {
@@ -160,8 +155,6 @@ func (s *LazilyPersistentStoreColumn) IsDataAvailable(ctx context.Context, curre
 
 // fullCommitmentsToCheck returns the commitments to check for a given block.
 func (s *LazilyPersistentStoreColumn) fullCommitmentsToCheck(nodeID enode.ID, block blocks.ROBlock, currentSlot primitives.Slot) (*safeCommitmentsArray, error) {
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
-
 	// Return early for blocks that are pre-Fulu.
 	if block.Version() < version.Fulu {
 		return &safeCommitmentsArray{}, nil
@@ -171,7 +164,7 @@ func (s *LazilyPersistentStoreColumn) fullCommitmentsToCheck(nodeID enode.ID, bl
 	blockSlot := block.Block().Slot()
 	blockEpoch := slots.ToEpoch(blockSlot)
 
-	// Compute the current epoch.
+	// Compute the current spoch.
 	currentEpoch := slots.ToEpoch(currentSlot)
 
 	// Return early if the request is out of the MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS window.
@@ -190,9 +183,11 @@ func (s *LazilyPersistentStoreColumn) fullCommitmentsToCheck(nodeID enode.ID, bl
 		return &safeCommitmentsArray{}, nil
 	}
 
+	// Retrieve the groups count.
+	custodyGroupCount := s.custodyInfo.ActualGroupCount()
+
 	// Retrieve peer info.
-	samplingSize := max(s.custodyGroupCount, samplesPerSlot)
-	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
+	peerInfo, _, err := peerdas.Info(nodeID, custodyGroupCount)
 	if err != nil {
 		return nil, errors.Wrap(err, "peer info")
 	}

beacon-chain/das/availability_columns_test.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
+	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -27,7 +29,7 @@ var commitments = [][]byte{
 func TestPersist(t *testing.T) {
 	t.Run("no sidecars", func(t *testing.T) {
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
-		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, &peerdas.CustodyInfo{})
 		err := lazilyPersistentStoreColumns.Persist(0)
 		require.NoError(t, err)
 		require.Equal(t, 0, len(lazilyPersistentStoreColumns.cache.entries))
@@ -42,7 +44,7 @@ func TestPersist(t *testing.T) {
 		}
 
 		roSidecars, _ := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
-		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, &peerdas.CustodyInfo{})
 
 		err := lazilyPersistentStoreColumns.Persist(0, roSidecars...)
 		require.ErrorIs(t, err, errMixedRoots)
@@ -57,7 +59,7 @@ func TestPersist(t *testing.T) {
 		}
 
 		roSidecars, _ := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
-		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, &peerdas.CustodyInfo{})
 
 		err := lazilyPersistentStoreColumns.Persist(1_000_000, roSidecars...)
 		require.NoError(t, err)
@@ -74,7 +76,7 @@ func TestPersist(t *testing.T) {
 		}
 
 		roSidecars, roDataColumns := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
-		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, &peerdas.CustodyInfo{})
 
 		err := lazilyPersistentStoreColumns.Persist(slot, roSidecars...)
 		require.NoError(t, err)
@@ -112,7 +114,7 @@ func TestIsDataAvailable(t *testing.T) {
 		signedRoBlock := newSignedRoBlock(t, signedBeaconBlockFulu)
 
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
-		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, 0)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, &peerdas.CustodyInfo{})
 
 		err := lazilyPersistentStoreColumns.IsDataAvailable(ctx, 0 /*current slot*/, signedRoBlock)
 		require.NoError(t, err)
@@ -133,9 +135,9 @@ func TestIsDataAvailable(t *testing.T) {
 		root := signedRoBlock.Root()
 
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
-		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, 0)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, &peerdas.CustodyInfo{})
 
-		indices := [...]uint64{1, 17, 19, 42, 75, 87, 102, 117}
+		indices := [...]uint64{1, 17, 87, 102}
 		dataColumnsParams := make([]util.DataColumnParam, 0, len(indices))
 		for _, index := range indices {
 			dataColumnParams := util.DataColumnParam{
@@ -219,10 +221,14 @@ func TestFullCommitmentsToCheck(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			numberOfColumns := params.BeaconConfig().NumberOfColumns
+			resetFlags := flags.Get()
+			gFlags := new(flags.GlobalFlags)
+			gFlags.SubscribeAllDataSubnets = true
+			flags.Init(gFlags)
+			defer flags.Init(resetFlags)
 
 			b := tc.block(t)
-			s := NewLazilyPersistentStoreColumn(nil, enode.ID{}, nil, numberOfColumns)
+			s := NewLazilyPersistentStoreColumn(nil, enode.ID{}, nil, &peerdas.CustodyInfo{})
 
 			commitmentsArray, err := s.fullCommitmentsToCheck(enode.ID{}, b, tc.slot)
 			require.NoError(t, err)

beacon-chain/das/blob_cache.go

@@ -99,26 +99,20 @@ func (e *blobCacheEntry) filter(root [32]byte, kc [][]byte, slot primitives.Slot
 		if e.diskSummary.HasIndex(i) {
 			continue
 		}
-		// Check if e.scs has this index before accessing
-		var sidecar *blocks.ROBlob
-		if i < uint64(len(e.scs)) {
-			sidecar = e.scs[i]
-		}
-
 		if kc[i] == nil {
-			if sidecar != nil {
-				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, sidecar.KzgCommitment)
+			if e.scs[i] != nil {
+				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, e.scs[i].KzgCommitment)
 			}
 			continue
 		}
 
-		if sidecar == nil {
+		if e.scs[i] == nil {
 			return nil, errors.Wrapf(errMissingSidecar, "root=%#x, index=%#x", root, i)
 		}
-		if !bytes.Equal(kc[i], sidecar.KzgCommitment) {
-			return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, block commitment=%#x", root, i, sidecar.KzgCommitment, kc[i])
+		if !bytes.Equal(kc[i], e.scs[i].KzgCommitment) {
+			return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, block commitment=%#x", root, i, e.scs[i].KzgCommitment, kc[i])
 		}
-		scs = append(scs, *sidecar)
+		scs = append(scs, *e.scs[i])
 	}
 
 	return scs, nil

beacon-chain/das/blob_cache_test.go

@@ -155,41 +155,6 @@ func TestFilter(t *testing.T) {
 			},
 			err: errCommitmentMismatch,
 		},
-		{
-			name: "empty scs array with commitments",
-			setup: func(t *testing.T) (*blobCacheEntry, [][]byte, []blocks.ROBlob) {
-				// This reproduces the panic condition where entry.scs is empty or nil
-				// but we have commitments to check
-				entry := &blobCacheEntry{
-					scs: nil, // Empty/nil array that caused the panic
-				}
-				// Create a commitment that would trigger the check at index 0
-				commits := [][]byte{
-					bytesutil.PadTo([]byte("commitment1"), 48),
-				}
-				return entry, commits, nil
-			},
-			err: errMissingSidecar,
-		},
-		{
-			name: "scs array shorter than commitments",
-			setup: func(t *testing.T) (*blobCacheEntry, [][]byte, []blocks.ROBlob) {
-				// This reproduces the condition where entry.scs exists but is shorter
-				// than the number of commitments we're checking
-				entry := &blobCacheEntry{
-					scs: make([]*blocks.ROBlob, 2), // Only 2 slots
-				}
-				// Create 4 commitments, accessing index 2 and 3 would have panicked
-				commits := [][]byte{
-					nil,
-					nil,
-					bytesutil.PadTo([]byte("commitment3"), 48),
-					bytesutil.PadTo([]byte("commitment4"), 48),
-				}
-				return entry, commits, nil
-			},
-			err: errMissingSidecar,
-		},
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {

beacon-chain/db/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//cmd/beacon-chain:__subpackages__",
-        "//genesis:__subpackages__",
         "//testing/slasher/simulator:__pkg__",
         "//tools:__subpackages__",
     ],

beacon-chain/db/alias.go

@@ -10,11 +10,6 @@ type ReadOnlyDatabase = iface.ReadOnlyDatabase
 // about head info. For head info, use github.com/prysmaticlabs/prysm/blockchain.HeadFetcher.
 type NoHeadAccessDatabase = iface.NoHeadAccessDatabase
 
-// ReadOnlyDatabaseWithSeqNum exposes Prysm's Ethereum data backend for read access only, no information about
-// head info, but with read/write access to the p2p metadata sequence number.
-// This is used for the p2p service.
-type ReadOnlyDatabaseWithSeqNum = iface.ReadOnlyDatabaseWithSeqNum
-
 // HeadAccessDatabase exposes Prysm's Ethereum backend for read/write access with information about
 // chain head information. This interface should be used sparingly as the HeadFetcher is the source
 // of truth around chain head information while this interface serves as persistent storage for the

beacon-chain/db/filesystem/data_column.go

@@ -251,7 +251,7 @@ func (dcs *DataColumnStorage) Summary(root [fieldparams.RootLength]byte) DataCol
 }
 
 // Save saves data column sidecars into the database and asynchronously performs pruning.
-// The returned channel is closed when the pruning is complete.
+// The returned chanel is closed when the pruning is complete.
 func (dcs *DataColumnStorage) Save(dataColumnSidecars []blocks.VerifiedRODataColumn) error {
 	startTime := time.Now()
 
@@ -266,7 +266,8 @@ func (dcs *DataColumnStorage) Save(dataColumnSidecars []blocks.VerifiedRODataCol
 		return errWrongNumberOfColumns
 	}
 
-	dataColumnSidecarsByRoot := make(map[[fieldparams.RootLength]byte][]blocks.VerifiedRODataColumn)
+	highestEpoch := primitives.Epoch(0)
+	dataColumnSidecarsbyRoot := make(map[[fieldparams.RootLength]byte][]blocks.VerifiedRODataColumn)
 
 	// Group data column sidecars by root.
 	for _, dataColumnSidecar := range dataColumnSidecars {
@@ -277,20 +278,23 @@ func (dcs *DataColumnStorage) Save(dataColumnSidecars []blocks.VerifiedRODataCol
 
 		// Group data column sidecars by root.
 		root := dataColumnSidecar.BlockRoot()
-		dataColumnSidecarsByRoot[root] = append(dataColumnSidecarsByRoot[root], dataColumnSidecar)
+		dataColumnSidecarsbyRoot[root] = append(dataColumnSidecarsbyRoot[root], dataColumnSidecar)
 	}
 
-	for root, dataColumnSidecars := range dataColumnSidecarsByRoot {
+	for root, dataColumnSidecars := range dataColumnSidecarsbyRoot {
 		// Safety check all data column sidecars for this root are from the same slot.
-		slot := dataColumnSidecars[0].Slot()
+		firstSlot := dataColumnSidecars[0].SignedBlockHeader.Header.Slot
 		for _, dataColumnSidecar := range dataColumnSidecars[1:] {
-			if dataColumnSidecar.Slot() != slot {
+			if dataColumnSidecar.SignedBlockHeader.Header.Slot != firstSlot {
 				return errDataColumnSidecarsFromDifferentSlots
 			}
 		}
 
+		// Set the highest epoch.
+		epoch := slots.ToEpoch(dataColumnSidecars[0].Slot())
+		highestEpoch = max(highestEpoch, epoch)
+
 		// Save data columns in the filesystem.
-		epoch := slots.ToEpoch(slot)
 		if err := dcs.saveFilesystem(root, epoch, dataColumnSidecars); err != nil {
 			return errors.Wrap(err, "save filesystem")
 		}
@@ -302,7 +306,7 @@ func (dcs *DataColumnStorage) Save(dataColumnSidecars []blocks.VerifiedRODataCol
 		}
 
 		// Compute the data columns ident.
-		dataColumnsIdent := DataColumnsIdent{Root: root, Epoch: epoch, Indices: indices}
+		dataColumnsIdent := DataColumnsIdent{Root: root, Epoch: slots.ToEpoch(dataColumnSidecars[0].Slot()), Indices: indices}
 
 		// Set data columns in the cache.
 		if err := dcs.cache.set(dataColumnsIdent); err != nil {

beacon-chain/db/filesystem/doc.go

@@ -20,7 +20,7 @@ File organisation
   The remaining 7 bits (from 0 to 127) represent the index of the data column.
   This sentinel bit is needed to distinguish between the column with index 0 and no column.
   Example: If the column with index 5 is in the 3th position in the file, then indices[5] = 0x80 + 0x03 = 0x83.
-- The rest of the file is a repeat of the SSZ encoded data column sidecars.
+- The rest of the file is a repeat of the SSZ encoded data columns sidecars.
 
 
 |------------------------------------------|------------------------------------------------------------------------------------|
@@ -75,7 +75,7 @@ data-columns
 
 Computation of the maximum size of a DataColumnSidecar
 ------------------------------------------------------
-https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#datacolumnsidecar
+https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/das-core.md#datacolumnsidecar
 
 
 class DataColumnSidecar(Container):

beacon-chain/db/iface/interface.go

@@ -33,7 +33,6 @@ type ReadOnlyDatabase interface {
 	IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool
 	FinalizedChildBlock(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error)
 	HighestRootsBelowSlot(ctx context.Context, slot primitives.Slot) (primitives.Slot, [][32]byte, error)
-	EarliestSlot(ctx context.Context) (primitives.Slot, error)
 	// State related methods.
 	State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 	StateOrError(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
@@ -57,25 +56,14 @@ type ReadOnlyDatabase interface {
 	// Fee recipients operations.
 	FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error)
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
-	// Light client operations
+	// light client operations
 	LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error)
 	LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error)
 	LightClientBootstrap(ctx context.Context, blockRoot []byte) (interfaces.LightClientBootstrap, error)
-	// Origin checkpoint sync support
+
+	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	BackfillStatus(context.Context) (*dbval.BackfillStatus, error)
-
-	// P2P Metadata operations.
-	MetadataSeqNum(ctx context.Context) (uint64, error)
-}
-
-// ReadOnlyDatabaseWithSeqNum defines a struct which has read access to database methods
-// and also has read/write access to the p2p metadata sequence number.
-// Only used for the p2p service.
-type ReadOnlyDatabaseWithSeqNum interface {
-	ReadOnlyDatabase
-
-	SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error
 }
 
 // NoHeadAccessDatabase defines a struct without access to chain head data.
@@ -114,13 +102,6 @@ type NoHeadAccessDatabase interface {
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
 	DeleteHistoricalDataBeforeSlot(ctx context.Context, slot primitives.Slot, batchSize int) (int, error)
-
-	// Custody operations.
-	UpdateSubscribedToAllDataSubnets(ctx context.Context, subscribed bool) (bool, error)
-	UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error)
-
-	// P2P Metadata operations.
-	SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error
 }
 
 // HeadAccessDatabase defines a struct with access to reading chain head data.

beacon-chain/db/kv/BUILD.bazel

@@ -8,7 +8,6 @@ go_library(
         "backup.go",
         "blocks.go",
         "checkpoint.go",
-        "custody.go",
         "deposit_contract.go",
         "encoding.go",
         "error.go",
@@ -24,7 +23,6 @@ go_library(
         "migration_block_slot_index.go",
         "migration_finalized_parent.go",
         "migration_state_validators.go",
-        "p2p.go",
         "schema.go",
         "state.go",
         "state_summary.go",
@@ -40,6 +38,7 @@ go_library(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -51,7 +50,6 @@ go_library(
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/detect:go_default_library",
-        "//genesis:go_default_library",
         "//io/file:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
@@ -85,7 +83,6 @@ go_test(
         "backup_test.go",
         "blocks_test.go",
         "checkpoint_test.go",
-        "custody_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
         "execution_chain_test.go",
@@ -97,7 +94,6 @@ go_test(
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
-        "p2p_test.go",
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",
@@ -110,6 +106,7 @@ go_test(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -119,7 +116,6 @@ go_test(
         "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/db/kv/blocks.go

@@ -860,47 +860,6 @@ func (s *Store) SaveRegistrationsByValidatorIDs(ctx context.Context, ids []primi
 	})
 }
 
-// EarliestStoredSlot returns the earliest slot in the database.
-func (s *Store) EarliestSlot(ctx context.Context) (primitives.Slot, error) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	_, span := trace.StartSpan(ctx, "BeaconDB.EarliestSlot")
-	defer span.End()
-
-	earliestAvailableSlot := primitives.Slot(0)
-	err := s.db.View(func(tx *bolt.Tx) error {
-		// Retrieve the root corresponding to the earliest available block.
-		c := tx.Bucket(blockSlotIndicesBucket).Cursor()
-		k, v := c.First()
-		if k == nil || v == nil {
-			return ErrNotFound
-		}
-		slot := bytesutil.BytesToSlotBigEndian(k)
-
-		// The genesis block may be indexed in this bucket, even if we started from a checkpoint.
-		// Because of this, we check the next block. If the next block is still in the genesis epoch,
-		// then we consider we have the whole chain.
-		if slot != 0 {
-			earliestAvailableSlot = slot
-		}
-
-		k, v = c.Next()
-		if k == nil || v == nil {
-			// Only the genesis block is available.
-			return nil
-		}
-		slot = bytesutil.BytesToSlotBigEndian(k)
-		if slot < slotsPerEpoch {
-			// We are still in the genesis epoch, so we consider we have the whole chain.
-			return nil
-		}
-
-		earliestAvailableSlot = slot
-		return nil
-	})
-
-	return earliestAvailableSlot, err
-}
-
 type slotRoot struct {
 	slot primitives.Slot
 	root [32]byte
@@ -924,7 +883,7 @@ func (s *Store) slotRootsInRange(ctx context.Context, start, end primitives.Slot
 		c := bkt.Cursor()
 		for k, v := c.Seek(key); ; /* rely on internal checks to exit */ k, v = c.Prev() {
 			if len(k) == 0 && len(v) == 0 {
-				// The `edge` variable and this `if` deal with 2 edge cases:
+				// The `edge`` variable and this `if` deal with 2 edge cases:
 				// - Seeking past the end of the bucket (the `end` param is higher than the highest slot).
 				// - Seeking before the beginning of the bucket (the `start` param is lower than the lowest slot).
 				// In both of these cases k,v will be nil and we can handle the same way using `edge` to

beacon-chain/db/kv/blocks_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"fmt"
 	"testing"
 	"time"
@@ -1328,86 +1327,3 @@ func TestStore_RegistrationsByValidatorID(t *testing.T) {
 	want := errors.Wrap(ErrNotFoundFeeRecipient, "validator id 3")
 	require.Equal(t, want.Error(), err.Error())
 }
-
-// Block creates a phase0 beacon block at the specified slot and saves it to the database.
-func createAndSaveBlock(t *testing.T, ctx context.Context, db *Store, slot primitives.Slot) {
-	block := util.NewBeaconBlock()
-	block.Block.Slot = slot
-
-	wrappedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wrappedBlock))
-}
-
-func TestStore_EarliestSlot(t *testing.T) {
-	ctx := t.Context()
-
-	t.Run("empty database returns ErrNotFound", func(t *testing.T) {
-		db := setupDB(t)
-
-		slot, err := db.EarliestSlot(ctx)
-		require.ErrorIs(t, err, ErrNotFound)
-		assert.Equal(t, primitives.Slot(0), slot)
-	})
-
-	t.Run("database with only genesis block", func(t *testing.T) {
-		db := setupDB(t)
-
-		// Create and save genesis block (slot 0)
-		createAndSaveBlock(t, ctx, db, 0)
-
-		slot, err := db.EarliestSlot(ctx)
-		require.NoError(t, err)
-		assert.Equal(t, primitives.Slot(0), slot)
-	})
-
-	t.Run("database with genesis and blocks in genesis epoch", func(t *testing.T) {
-		db := setupDB(t)
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-
-		// Create and save genesis block (slot 0)
-		createAndSaveBlock(t, ctx, db, 0)
-
-		// Create and save a block in the genesis epoch
-		createAndSaveBlock(t, ctx, db, primitives.Slot(slotsPerEpoch-1))
-
-		slot, err := db.EarliestSlot(ctx)
-		require.NoError(t, err)
-		assert.Equal(t, primitives.Slot(0), slot)
-	})
-
-	t.Run("database with genesis and blocks beyond genesis epoch", func(t *testing.T) {
-		db := setupDB(t)
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-
-		// Create and save genesis block (slot 0)
-		createAndSaveBlock(t, ctx, db, 0)
-
-		// Create and save a block beyond the genesis epoch
-		nextEpochSlot := primitives.Slot(slotsPerEpoch)
-		createAndSaveBlock(t, ctx, db, nextEpochSlot)
-
-		slot, err := db.EarliestSlot(ctx)
-		require.NoError(t, err)
-		assert.Equal(t, nextEpochSlot, slot)
-	})
-
-	t.Run("database starting from checkpoint (non-zero earliest slot)", func(t *testing.T) {
-		db := setupDB(t)
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-
-		// Simulate starting from a checkpoint by creating blocks starting from a later slot
-		checkpointSlot := primitives.Slot(slotsPerEpoch * 10) // 10 epochs later
-		nextEpochSlot := checkpointSlot + slotsPerEpoch
-
-		// Create and save first block at checkpoint slot
-		createAndSaveBlock(t, ctx, db, checkpointSlot)
-
-		// Create and save another block in the next epoch
-		createAndSaveBlock(t, ctx, db, nextEpochSlot)
-
-		slot, err := db.EarliestSlot(ctx)
-		require.NoError(t, err)
-		assert.Equal(t, nextEpochSlot, slot)
-	})
-}

beacon-chain/db/kv/custody.go

@@ -1,129 +0,0 @@
-package kv
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	bolt "go.etcd.io/bbolt"
-)
-
-// UpdateCustodyInfo atomically updates the custody group count only it is greater than the stored one.
-// In this case, it also updates the earliest available slot with the provided value.
-// It returns the (potentially updated) custody group count and earliest available slot.
-func (s *Store) UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.UpdateCustodyInfo")
-	defer span.End()
-
-	storedGroupCount, storedEarliestAvailableSlot := uint64(0), primitives.Slot(0)
-	if err := s.db.Update(func(tx *bolt.Tx) error {
-		// Retrieve the custody bucket.
-		bucket, err := tx.CreateBucketIfNotExists(custodyBucket)
-		if err != nil {
-			return errors.Wrap(err, "create custody bucket")
-		}
-
-		// Retrieve the stored custody group count.
-		storedGroupCountBytes := bucket.Get(groupCountKey)
-		if len(storedGroupCountBytes) != 0 {
-			storedGroupCount = bytesutil.BytesToUint64BigEndian(storedGroupCountBytes)
-		}
-
-		// Retrieve the stored earliest available slot.
-		storedEarliestAvailableSlotBytes := bucket.Get(earliestAvailableSlotKey)
-		if len(storedEarliestAvailableSlotBytes) != 0 {
-			storedEarliestAvailableSlot = primitives.Slot(bytesutil.BytesToUint64BigEndian(storedEarliestAvailableSlotBytes))
-		}
-
-		// Exit early if the new custody group count is lower than or equal to the stored one.
-		if custodyGroupCount <= storedGroupCount {
-			return nil
-		}
-
-		storedGroupCount, storedEarliestAvailableSlot = custodyGroupCount, earliestAvailableSlot
-
-		// Store the earliest available slot.
-		bytes := bytesutil.Uint64ToBytesBigEndian(uint64(earliestAvailableSlot))
-		if err := bucket.Put(earliestAvailableSlotKey, bytes); err != nil {
-			return errors.Wrap(err, "put earliest available slot")
-		}
-
-		// Store the custody group count.
-		bytes = bytesutil.Uint64ToBytesBigEndian(custodyGroupCount)
-		if err := bucket.Put(groupCountKey, bytes); err != nil {
-			return errors.Wrap(err, "put custody group count")
-		}
-
-		return nil
-	}); err != nil {
-		return 0, 0, err
-	}
-
-	log.WithFields(logrus.Fields{
-		"earliestAvailableSlot": storedEarliestAvailableSlot,
-		"groupCount":            storedGroupCount,
-	}).Debug("Custody info")
-
-	return storedEarliestAvailableSlot, storedGroupCount, nil
-}
-
-// UpdateSubscribedToAllDataSubnets updates the "subscribed to all data subnets" status in the database
-// only if `subscribed` is `true`.
-// It returns the previous subscription status.
-func (s *Store) UpdateSubscribedToAllDataSubnets(ctx context.Context, subscribed bool) (bool, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.UpdateSubscribedToAllDataSubnets")
-	defer span.End()
-
-	result := false
-	if !subscribed {
-		if err := s.db.View(func(tx *bolt.Tx) error {
-			// Retrieve the custody bucket.
-			bucket := tx.Bucket(custodyBucket)
-			if bucket == nil {
-				return nil
-			}
-
-			// Retrieve the subscribe all data subnets flag.
-			bytes := bucket.Get(subscribeAllDataSubnetsKey)
-			if len(bytes) == 0 {
-				return nil
-			}
-
-			if bytes[0] == 1 {
-				result = true
-			}
-
-			return nil
-		}); err != nil {
-			return false, err
-		}
-
-		return result, nil
-	}
-
-	if err := s.db.Update(func(tx *bolt.Tx) error {
-		// Retrieve the custody bucket.
-		bucket, err := tx.CreateBucketIfNotExists(custodyBucket)
-		if err != nil {
-			return errors.Wrap(err, "create custody bucket")
-		}
-
-		bytes := bucket.Get(subscribeAllDataSubnetsKey)
-		if len(bytes) != 0 && bytes[0] == 1 {
-			result = true
-		}
-
-		if err := bucket.Put(subscribeAllDataSubnetsKey, []byte{1}); err != nil {
-			return errors.Wrap(err, "put subscribe all data subnets")
-		}
-
-		return nil
-	}); err != nil {
-		return false, err
-	}
-
-	return result, nil
-}

beacon-chain/db/kv/custody_test.go

@@ -1,176 +0,0 @@
-package kv
-
-import (
-	"context"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	bolt "go.etcd.io/bbolt"
-)
-
-// getCustodyInfoFromDB reads the custody info directly from the database for testing purposes.
-func getCustodyInfoFromDB(t *testing.T, db *Store) (primitives.Slot, uint64) {
-	t.Helper()
-	var earliestSlot primitives.Slot
-	var groupCount uint64
-
-	err := db.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(custodyBucket)
-		if bucket == nil {
-			return nil
-		}
-
-		// Read group count
-		groupCountBytes := bucket.Get(groupCountKey)
-		if len(groupCountBytes) != 0 {
-			groupCount = bytesutil.BytesToUint64BigEndian(groupCountBytes)
-		}
-
-		// Read earliest available slot
-		earliestSlotBytes := bucket.Get(earliestAvailableSlotKey)
-		if len(earliestSlotBytes) != 0 {
-			earliestSlot = primitives.Slot(bytesutil.BytesToUint64BigEndian(earliestSlotBytes))
-		}
-
-		return nil
-	})
-	require.NoError(t, err)
-
-	return earliestSlot, groupCount
-}
-
-// getSubscriptionStatusFromDB reads the subscription status directly from the database for testing purposes.
-func getSubscriptionStatusFromDB(t *testing.T, db *Store) bool {
-	t.Helper()
-	var subscribed bool
-
-	err := db.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(custodyBucket)
-		if bucket == nil {
-			return nil
-		}
-
-		bytes := bucket.Get(subscribeAllDataSubnetsKey)
-		if len(bytes) != 0 && bytes[0] == 1 {
-			subscribed = true
-		}
-
-		return nil
-	})
-	require.NoError(t, err)
-
-	return subscribed
-}
-
-func TestUpdateCustodyInfo(t *testing.T) {
-	ctx := t.Context()
-
-	t.Run("initial update with empty database", func(t *testing.T) {
-		const (
-			earliestSlot = primitives.Slot(100)
-			groupCount   = uint64(5)
-		)
-
-		db := setupDB(t)
-
-		slot, count, err := db.UpdateCustodyInfo(ctx, earliestSlot, groupCount)
-		require.NoError(t, err)
-		require.Equal(t, earliestSlot, slot)
-		require.Equal(t, groupCount, count)
-
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, earliestSlot, storedSlot)
-		require.Equal(t, groupCount, storedCount)
-	})
-
-	t.Run("update with higher group count", func(t *testing.T) {
-		const (
-			initialSlot  = primitives.Slot(100)
-			initialCount = uint64(5)
-			earliestSlot = primitives.Slot(200)
-			groupCount   = uint64(10)
-		)
-
-		db := setupDB(t)
-
-		_, _, err := db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
-		require.NoError(t, err)
-
-		slot, count, err := db.UpdateCustodyInfo(ctx, earliestSlot, groupCount)
-		require.NoError(t, err)
-		require.Equal(t, earliestSlot, slot)
-		require.Equal(t, groupCount, count)
-
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, earliestSlot, storedSlot)
-		require.Equal(t, groupCount, storedCount)
-	})
-
-	t.Run("update with lower group count should not update", func(t *testing.T) {
-		const (
-			initialSlot  = primitives.Slot(200)
-			initialCount = uint64(10)
-			earliestSlot = primitives.Slot(300)
-			groupCount   = uint64(8)
-		)
-
-		db := setupDB(t)
-
-		_, _, err := db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
-		require.NoError(t, err)
-
-		slot, count, err := db.UpdateCustodyInfo(ctx, earliestSlot, groupCount)
-		require.NoError(t, err)
-		require.Equal(t, initialSlot, slot)
-		require.Equal(t, initialCount, count)
-
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, initialSlot, storedSlot)
-		require.Equal(t, initialCount, storedCount)
-	})
-}
-
-func TestUpdateSubscribedToAllDataSubnets(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("initial update with empty database - set to false", func(t *testing.T) {
-		db := setupDB(t)
-
-		prev, err := db.UpdateSubscribedToAllDataSubnets(ctx, false)
-		require.NoError(t, err)
-		require.Equal(t, false, prev)
-
-		stored := getSubscriptionStatusFromDB(t, db)
-		require.Equal(t, false, stored)
-	})
-
-	t.Run("attempt to update from true to false (should not change)", func(t *testing.T) {
-		db := setupDB(t)
-
-		_, err := db.UpdateSubscribedToAllDataSubnets(ctx, true)
-		require.NoError(t, err)
-
-		prev, err := db.UpdateSubscribedToAllDataSubnets(ctx, false)
-		require.NoError(t, err)
-		require.Equal(t, true, prev)
-
-		stored := getSubscriptionStatusFromDB(t, db)
-		require.Equal(t, true, stored)
-	})
-
-	t.Run("attempt to update from true to false (should not change)", func(t *testing.T) {
-		db := setupDB(t)
-
-		_, err := db.UpdateSubscribedToAllDataSubnets(ctx, true)
-		require.NoError(t, err)
-
-		prev, err := db.UpdateSubscribedToAllDataSubnets(ctx, true)
-		require.NoError(t, err)
-		require.Equal(t, true, prev)
-
-		stored := getSubscriptionStatusFromDB(t, db)
-		require.Equal(t, true, stored)
-	})
-}

beacon-chain/db/kv/error.go

@@ -19,9 +19,6 @@ var ErrNotFoundGenesisBlockRoot = errors.Wrap(ErrNotFound, "OriginGenesisRoot")
 // ErrNotFoundFeeRecipient is a not found error specifically for the fee recipient getter
 var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
 
-// ErrNotFoundMetadataSeqNum is a not found error specifically for the metadata sequence number getter
-var ErrNotFoundMetadataSeqNum = errors.Wrap(ErrNotFound, "metadata sequence number")
-
 var errEmptyBlockSlice = errors.New("[]blocks.ROBlock is empty")
 var errIncorrectBlockParent = errors.New("unexpected missing or forked blocks in a []ROBlock")
 var errFinalizedChildNotFound = errors.New("unable to find finalized root descending from backfill batch")

beacon-chain/db/kv/genesis.go

@@ -8,7 +8,6 @@ import (
 	dbIface "github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/encoding/ssz/detect"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
@@ -98,22 +97,8 @@ func (s *Store) EnsureEmbeddedGenesis(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	if !state.IsNil(gs) {
+	if gs != nil && !gs.IsNil() {
 		return s.SaveGenesisData(ctx, gs)
 	}
 	return nil
 }
-
-type LegacyGenesisProvider struct {
-	store *Store
-}
-
-func NewLegacyGenesisProvider(store *Store) *LegacyGenesisProvider {
-	return &LegacyGenesisProvider{store: store}
-}
-
-var _ genesis.Provider = &LegacyGenesisProvider{}
-
-func (p *LegacyGenesisProvider) Genesis(ctx context.Context) (state.BeaconState, error) {
-	return p.store.LegacyGenesisState(ctx)
-}

beacon-chain/db/kv/genesis_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -153,7 +152,6 @@ func TestEnsureEmbeddedGenesis(t *testing.T) {
 		require.NoError(t, undo())
 	}()
 
-	genesis.StoreEmbeddedDuringTest(t, params.BeaconConfig().ConfigName)
 	ctx := t.Context()
 	db := setupDB(t)
 

beacon-chain/db/kv/kv.go

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

beacon-chain/db/kv/p2p.go

@@ -1,42 +0,0 @@
-package kv
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
-	bolt "go.etcd.io/bbolt"
-)
-
-// MetadataSeqNum retrieves the p2p metadata sequence number from the database.
-// It returns 0 and ErrNotFoundMetadataSeqNum if the key does not exist.
-func (s *Store) MetadataSeqNum(ctx context.Context) (uint64, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.MetadataSeqNum")
-	defer span.End()
-
-	var seqNum uint64
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(chainMetadataBucket)
-		val := bkt.Get(metadataSequenceNumberKey)
-		if val == nil {
-			return ErrNotFoundMetadataSeqNum
-		}
-
-		seqNum = bytesutil.BytesToUint64BigEndian(val)
-		return nil
-	})
-
-	return seqNum, err
-}
-
-// SaveMetadataSeqNum saves the p2p metadata sequence number to the database.
-func (s *Store) SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveMetadataSeqNum")
-	defer span.End()
-
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(chainMetadataBucket)
-		val := bytesutil.Uint64ToBytesBigEndian(seqNum)
-		return bkt.Put(metadataSequenceNumberKey, val)
-	})
-}

beacon-chain/db/kv/p2p_test.go

@@ -1,33 +0,0 @@
-package kv
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestStore_MetadataSeqNum(t *testing.T) {
-	ctx := t.Context()
-	db := setupDB(t)
-
-	seqNum, err := db.MetadataSeqNum(ctx)
-	require.ErrorIs(t, err, ErrNotFoundMetadataSeqNum)
-	assert.Equal(t, uint64(0), seqNum)
-
-	initialSeqNum := uint64(42)
-	err = db.SaveMetadataSeqNum(ctx, initialSeqNum)
-	require.NoError(t, err)
-
-	retrievedSeqNum, err := db.MetadataSeqNum(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, initialSeqNum, retrievedSeqNum)
-
-	updatedSeqNum := uint64(43)
-	err = db.SaveMetadataSeqNum(ctx, updatedSeqNum)
-	require.NoError(t, err)
-
-	retrievedSeqNum, err = db.MetadataSeqNum(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, updatedSeqNum, retrievedSeqNum)
-}

beacon-chain/db/kv/schema.go

@@ -42,7 +42,6 @@ var (
 	finalizedCheckpointKey     = []byte("finalized-checkpoint")
 	powchainDataKey            = []byte("powchain-data")
 	lastValidatedCheckpointKey = []byte("last-validated-checkpoint")
-	metadataSequenceNumberKey  = []byte("metadata-seq-number")
 
 	// Below keys are used to identify objects are to be fork compatible.
 	// Objects that are only compatible with specific forks should be prefixed with such keys.
@@ -71,10 +70,4 @@ var (
 
 	// Migrations
 	migrationsBucket = []byte("migrations")
-
-	// Custody
-	custodyBucket              = []byte("custody")
-	groupCountKey              = []byte("group-count")
-	earliestAvailableSlotKey   = []byte("earliest-available-slot")
-	subscribeAllDataSubnetsKey = []byte("subscribe-all-data-subnets")
 )

beacon-chain/db/kv/state.go

@@ -6,12 +6,14 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis"
 	statenative "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v6/config/features"
+	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -63,21 +65,21 @@ func (s *Store) StateOrError(ctx context.Context, blockRoot [32]byte) (state.Bea
 	return st, nil
 }
 
-func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
-	st, err := genesis.State()
-	if errors.Is(err, genesis.ErrGenesisStateNotInitialized) {
-		log.WithError(err).Error("genesis state not initialized, returning nil state. this should only happen in tests")
-		return nil, nil
-	}
-	return st, err
-}
-
 // GenesisState returns the genesis state in beacon chain.
-func (s *Store) LegacyGenesisState(ctx context.Context) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LegacyGenesisState")
+func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.GenesisState")
 	defer span.End()
 
-	var err error
+	cached, err := genesis.State(params.BeaconConfig().ConfigName)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return nil, err
+	}
+	span.SetAttributes(trace.BoolAttribute("cache_hit", cached != nil))
+	if cached != nil {
+		return cached, nil
+	}
+
 	var st state.BeaconState
 	err = s.db.View(func(tx *bolt.Tx) error {
 		// Retrieve genesis block's signing root from blocks bucket,
@@ -251,10 +253,6 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl
 			if err := s.processElectra(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
-		case *ethpb.BeaconStateFulu:
-			if err := s.processFulu(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
-				return err
-			}
 		default:
 			return errors.New("invalid state type")
 		}
@@ -370,24 +368,6 @@ func (s *Store) processElectra(ctx context.Context, pbState *ethpb.BeaconStateEl
 	return nil
 }
 
-func (s *Store) processFulu(ctx context.Context, pbState *ethpb.BeaconStateFulu, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
-	valEntries := pbState.Validators
-	pbState.Validators = make([]*ethpb.Validator, 0)
-	rawObj, err := pbState.MarshalSSZ()
-	if err != nil {
-		return err
-	}
-	encodedState := snappy.Encode(nil, append(fuluKey, rawObj...))
-	if err := bucket.Put(rootHash, encodedState); err != nil {
-		return err
-	}
-	pbState.Validators = valEntries
-	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
-		return err
-	}
-	return nil
-}
-
 func (s *Store) storeValidatorEntriesSeparately(ctx context.Context, tx *bolt.Tx, validatorsEntries map[string]*ethpb.Validator) error {
 	valBkt := tx.Bucket(stateValidatorsBucket)
 	for hashStr, validatorEntry := range validatorsEntries {

beacon-chain/db/kv/state_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -489,7 +488,7 @@ func TestGenesisState_CanSaveRetrieve(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(1))
 	require.NoError(t, db.SaveGenesisBlockRoot(t.Context(), headRoot))
-	genesis.StoreStateDuringTest(t, st)
+	require.NoError(t, db.SaveState(t.Context(), st, headRoot))
 
 	savedGenesisS, err := db.GenesisState(t.Context())
 	require.NoError(t, err)
@@ -662,7 +661,7 @@ func TestStore_GenesisState_CanGetHighestBelow(t *testing.T) {
 	require.NoError(t, err)
 	genesisRoot := [32]byte{'a'}
 	require.NoError(t, db.SaveGenesisBlockRoot(t.Context(), genesisRoot))
-	genesis.StoreStateDuringTest(t, genesisState)
+	require.NoError(t, db.SaveState(t.Context(), genesisState, genesisRoot))
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1

beacon-chain/db/kv/wss.go

@@ -43,7 +43,6 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		return errors.Wrap(err, "failed to initialize origin block w/ bytes + config+fork")
 	}
 	blk := wblk.Block()
-	slot := blk.Slot()
 
 	blockRoot, err := blk.HashTreeRoot()
 	if err != nil {
@@ -52,43 +51,43 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 
 	pr := blk.ParentRoot()
 	bf := &dbval.BackfillStatus{
-		LowSlot:       uint64(slot),
+		LowSlot:       uint64(wblk.Block().Slot()),
 		LowRoot:       blockRoot[:],
 		LowParentRoot: pr[:],
 		OriginRoot:    blockRoot[:],
-		OriginSlot:    uint64(slot),
+		OriginSlot:    uint64(wblk.Block().Slot()),
 	}
 
 	if err = s.SaveBackfillStatus(ctx, bf); err != nil {
 		return errors.Wrap(err, "unable to save backfill status data to db for checkpoint sync")
 	}
 
-	log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Info("Saving checkpoint data into database")
+	log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Info("Saving checkpoint block to db")
 	if err := s.SaveBlock(ctx, wblk); err != nil {
-		return errors.Wrap(err, "save block")
+		return errors.Wrap(err, "could not save checkpoint block")
 	}
 
 	// save state
+	log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Info("Calling SaveState")
 	if err = s.SaveState(ctx, state, blockRoot); err != nil {
-		return errors.Wrap(err, "save state")
+		return errors.Wrap(err, "could not save state")
 	}
-
 	if err = s.SaveStateSummary(ctx, &ethpb.StateSummary{
 		Slot: state.Slot(),
 		Root: blockRoot[:],
 	}); err != nil {
-		return errors.Wrap(err, "save state summary")
+		return errors.Wrap(err, "could not save state summary")
 	}
 
 	// mark block as head of chain, so that processing will pick up from this point
 	if err = s.SaveHeadBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "save head block root")
+		return errors.Wrap(err, "could not save head block root")
 	}
 
 	// save origin block root in a special key, to be used when the canonical
 	// origin (start of chain, ie alternative to genesis) block or state is needed
 	if err = s.SaveOriginCheckpointBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "save origin checkpoint block root")
+		return errors.Wrap(err, "could not save origin block root")
 	}
 
 	// rebuild the checkpoint from the block
@@ -97,18 +96,15 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 	if err != nil {
 		return err
 	}
-
 	chkpt := &ethpb.Checkpoint{
 		Epoch: primitives.Epoch(slotEpoch),
 		Root:  blockRoot[:],
 	}
-
 	if err = s.SaveJustifiedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "save justified checkpoint")
+		return errors.Wrap(err, "could not mark checkpoint sync block as justified")
 	}
-
 	if err = s.SaveFinalizedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "save finalized checkpoint")
+		return errors.Wrap(err, "could not mark checkpoint sync block as finalized")
 	}
 
 	return nil

beacon-chain/db/kv/wss_test.go

@@ -3,9 +3,9 @@ package kv
 import (
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
@@ -18,11 +18,7 @@ func TestSaveOrigin(t *testing.T) {
 	ctx := t.Context()
 	db := setupDB(t)
 
-	// Initialize genesis with mainnet config - this will load the embedded mainnet state
-	require.NoError(t, genesis.Initialize(ctx, t.TempDir()))
-
-	// Get the initialized genesis state
-	st, err := genesis.State()
+	st, err := genesis.State(params.MainnetName)
 	require.NoError(t, err)
 
 	sb, err := st.MarshalSSZ()

beacon-chain/execution/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "block_reader.go",
         "deposit.go",
         "engine_client.go",
+        "engine_client_focil.go",
         "errors.go",
         "log.go",
         "log_processing.go",
@@ -62,6 +63,7 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//:go_default_library",
         "@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library",
+        "@com_github_ethereum_go_ethereum//beacon/engine:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
@@ -125,7 +127,6 @@ go_test(
         "//contracts/deposit/mock:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//monitoring/clientstats:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",