gloas api structs

Add deposit request

.github/workflows/check-specrefs.yml

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

.github/workflows/go.yml

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

.golangci.yml

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

WORKSPACE

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

api/fallback/BUILD.bazel

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

api/fallback/fallback.go

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

api/fallback/fallback_test.go

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

api/fallback/log.go

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

api/grpc/BUILD.bazel

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

api/grpc/grpc_connection_provider.go

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

api/grpc/grpc_connection_provider_test.go

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

api/grpc/mock_grpc_provider.go

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

api/rest/BUILD.bazel

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

api/rest/mock_rest_provider.go

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

api/rest/rest_connection_provider.go

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

api/rest/rest_connection_provider_test.go

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

api/server/structs/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "conversions_blob.go",
         "conversions_block.go",
         "conversions_block_execution.go",
+        "conversions_gloas.go",
         "conversions_lightclient.go",
         "conversions_state.go",
         "endpoints_beacon.go",
@@ -57,10 +58,12 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//consensus-types/blocks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
     ],

api/server/structs/block.go

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

api/server/structs/conversions_block.go

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

api/server/structs/conversions_gloas.go

@@ -0,0 +1,81 @@
+package structs
+
+import (
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+func ROExecutionPayloadBidFromConsensus(b interfaces.ROExecutionPayloadBid) *ExecutionPayloadBid {
+	pbh := b.ParentBlockHash()
+	pbr := b.ParentBlockRoot()
+	bh := b.BlockHash()
+	pr := b.PrevRandao()
+	fr := b.FeeRecipient()
+	bcr := b.BlobKzgCommitmentsRoot()
+	return &ExecutionPayloadBid{
+		ParentBlockHash:        hexutil.Encode(pbh[:]),
+		ParentBlockRoot:        hexutil.Encode(pbr[:]),
+		BlockHash:              hexutil.Encode(bh[:]),
+		PrevRandao:             hexutil.Encode(pr[:]),
+		FeeRecipient:           hexutil.Encode(fr[:]),
+		GasLimit:               fmt.Sprintf("%d", b.GasLimit()),
+		BuilderIndex:           fmt.Sprintf("%d", b.BuilderIndex()),
+		Slot:                   fmt.Sprintf("%d", b.Slot()),
+		Value:                  fmt.Sprintf("%d", b.Value()),
+		ExecutionPayment:       fmt.Sprintf("%d", b.ExecutionPayment()),
+		BlobKzgCommitmentsRoot: hexutil.Encode(bcr[:]),
+	}
+}
+
+func BuildersFromConsensus(builders []*ethpb.Builder) []*Builder {
+	newBuilders := make([]*Builder, len(builders))
+	for i, b := range builders {
+		newBuilders[i] = BuilderFromConsensus(b)
+	}
+	return newBuilders
+}
+
+func BuilderFromConsensus(b *ethpb.Builder) *Builder {
+	return &Builder{
+		Pubkey:            hexutil.Encode(b.Pubkey),
+		Version:           hexutil.Encode(b.Version),
+		ExecutionAddress:  hexutil.Encode(b.ExecutionAddress),
+		Balance:           fmt.Sprintf("%d", b.Balance),
+		DepositEpoch:      fmt.Sprintf("%d", b.DepositEpoch),
+		WithdrawableEpoch: fmt.Sprintf("%d", b.WithdrawableEpoch),
+	}
+}
+
+func BuilderPendingPaymentsFromConsensus(payments []*ethpb.BuilderPendingPayment) []*BuilderPendingPayment {
+	newPayments := make([]*BuilderPendingPayment, len(payments))
+	for i, p := range payments {
+		newPayments[i] = BuilderPendingPaymentFromConsensus(p)
+	}
+	return newPayments
+}
+
+func BuilderPendingPaymentFromConsensus(p *ethpb.BuilderPendingPayment) *BuilderPendingPayment {
+	return &BuilderPendingPayment{
+		Weight:     fmt.Sprintf("%d", p.Weight),
+		Withdrawal: BuilderPendingWithdrawalFromConsensus(p.Withdrawal),
+	}
+}
+
+func BuilderPendingWithdrawalsFromConsensus(withdrawals []*ethpb.BuilderPendingWithdrawal) []*BuilderPendingWithdrawal {
+	newWithdrawals := make([]*BuilderPendingWithdrawal, len(withdrawals))
+	for i, w := range withdrawals {
+		newWithdrawals[i] = BuilderPendingWithdrawalFromConsensus(w)
+	}
+	return newWithdrawals
+}
+
+func BuilderPendingWithdrawalFromConsensus(w *ethpb.BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
+	return &BuilderPendingWithdrawal{
+		FeeRecipient: hexutil.Encode(w.FeeRecipient),
+		Amount:       fmt.Sprintf("%d", w.Amount),
+		BuilderIndex: fmt.Sprintf("%d", w.BuilderIndex),
+	}
+}

api/server/structs/conversions_state.go

@@ -972,3 +972,223 @@ func BeaconStateFuluFromConsensus(st beaconState.BeaconState) (*BeaconStateFulu,
 		ProposerLookahead:             lookahead,
 	}, nil
 }
+
+// ----------------------------------------------------------------------------
+// Gloas
+// ----------------------------------------------------------------------------
+
+func BeaconStateGloasFromConsensus(st beaconState.BeaconState) (*BeaconStateGloas, error) {
+	srcBr := st.BlockRoots()
+	br := make([]string, len(srcBr))
+	for i, r := range srcBr {
+		br[i] = hexutil.Encode(r)
+	}
+	srcSr := st.StateRoots()
+	sr := make([]string, len(srcSr))
+	for i, r := range srcSr {
+		sr[i] = hexutil.Encode(r)
+	}
+	srcHr := st.HistoricalRoots()
+	hr := make([]string, len(srcHr))
+	for i, r := range srcHr {
+		hr[i] = hexutil.Encode(r)
+	}
+	srcVotes := st.Eth1DataVotes()
+	votes := make([]*Eth1Data, len(srcVotes))
+	for i, e := range srcVotes {
+		votes[i] = Eth1DataFromConsensus(e)
+	}
+	srcVals := st.Validators()
+	vals := make([]*Validator, len(srcVals))
+	for i, v := range srcVals {
+		vals[i] = ValidatorFromConsensus(v)
+	}
+	srcBals := st.Balances()
+	bals := make([]string, len(srcBals))
+	for i, b := range srcBals {
+		bals[i] = fmt.Sprintf("%d", b)
+	}
+	srcRm := st.RandaoMixes()
+	rm := make([]string, len(srcRm))
+	for i, m := range srcRm {
+		rm[i] = hexutil.Encode(m)
+	}
+	srcSlashings := st.Slashings()
+	slashings := make([]string, len(srcSlashings))
+	for i, s := range srcSlashings {
+		slashings[i] = fmt.Sprintf("%d", s)
+	}
+	srcPrevPart, err := st.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	prevPart := make([]string, len(srcPrevPart))
+	for i, p := range srcPrevPart {
+		prevPart[i] = fmt.Sprintf("%d", p)
+	}
+	srcCurrPart, err := st.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currPart := make([]string, len(srcCurrPart))
+	for i, p := range srcCurrPart {
+		currPart[i] = fmt.Sprintf("%d", p)
+	}
+	srcIs, err := st.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	is := make([]string, len(srcIs))
+	for i, s := range srcIs {
+		is[i] = fmt.Sprintf("%d", s)
+	}
+	currSc, err := st.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSc, err := st.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	srcHs, err := st.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	hs := make([]*HistoricalSummary, len(srcHs))
+	for i, s := range srcHs {
+		hs[i] = HistoricalSummaryFromConsensus(s)
+	}
+	nwi, err := st.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	nwvi, err := st.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	drsi, err := st.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, err
+	}
+	dbtc, err := st.DepositBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	ebtc, err := st.ExitBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	eee, err := st.EarliestExitEpoch()
+	if err != nil {
+		return nil, err
+	}
+	cbtc, err := st.ConsolidationBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	ece, err := st.EarliestConsolidationEpoch()
+	if err != nil {
+		return nil, err
+	}
+	pbd, err := st.PendingDeposits()
+	if err != nil {
+		return nil, err
+	}
+	ppw, err := st.PendingPartialWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	pc, err := st.PendingConsolidations()
+	if err != nil {
+		return nil, err
+	}
+	srcLookahead, err := st.ProposerLookahead()
+	if err != nil {
+		return nil, err
+	}
+	lookahead := make([]string, len(srcLookahead))
+	for i, v := range srcLookahead {
+		lookahead[i] = fmt.Sprintf("%d", uint64(v))
+	}
+	// Gloas-specific fields
+	lepb, err := st.LatestExecutionPayloadBid()
+	if err != nil {
+		return nil, err
+	}
+	builders, err := st.Builders()
+	if err != nil {
+		return nil, err
+	}
+	nwbi, err := st.NextWithdrawalBuilderIndex()
+	if err != nil {
+		return nil, err
+	}
+	epa, err := st.ExecutionPayloadAvailability()
+	if err != nil {
+		return nil, err
+	}
+	bpp, err := st.BuilderPendingPayments()
+	if err != nil {
+		return nil, err
+	}
+	bpw, err := st.BuilderPendingWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	lbh, err := st.LatestBlockHash()
+	if err != nil {
+		return nil, err
+	}
+	pew, err := st.PayloadExpectedWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+
+	return &BeaconStateGloas{
+		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime().Unix()),
+		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
+		Slot:                          fmt.Sprintf("%d", st.Slot()),
+		Fork:                          ForkFromConsensus(st.Fork()),
+		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
+		BlockRoots:                    br,
+		StateRoots:                    sr,
+		HistoricalRoots:               hr,
+		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
+		Eth1DataVotes:                 votes,
+		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
+		Validators:                    vals,
+		Balances:                      bals,
+		RandaoMixes:                   rm,
+		Slashings:                     slashings,
+		PreviousEpochParticipation:    prevPart,
+		CurrentEpochParticipation:     currPart,
+		JustificationBits:             hexutil.Encode(st.JustificationBits()),
+		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
+		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
+		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
+		InactivityScores:              is,
+		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
+		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
+		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
+		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
+		HistoricalSummaries:           hs,
+		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
+		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
+		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
+		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
+		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
+		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
+		PendingDeposits:               PendingDepositsFromConsensus(pbd),
+		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
+		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
+		ProposerLookahead:             lookahead,
+		LatestExecutionPayloadBid:     ROExecutionPayloadBidFromConsensus(lepb),
+		Builders:                      BuildersFromConsensus(builders),
+		NextWithdrawalBuilderIndex:    fmt.Sprintf("%d", nwbi),
+		ExecutionPayloadAvailability:  hexutil.Encode(epa),
+		BuilderPendingPayments:        BuilderPendingPaymentsFromConsensus(bpp),
+		BuilderPendingWithdrawals:     BuilderPendingWithdrawalsFromConsensus(bpw),
+		LatestBlockHash:               hexutil.Encode(lbh[:]),
+		PayloadExpectedWithdrawals:    WithdrawalsFromConsensus(pew),
+	}, nil
+}

api/server/structs/conversions_test.go

@@ -1,11 +1,15 @@
 package structs
 
 import (
+	"bytes"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
@@ -346,6 +350,176 @@ func TestAttesterSlashing_FromConsensus(t *testing.T) {
 	assert.DeepEqual(t, expectedResult, result)
 }
 
+func TestROExecutionPayloadBidFromConsensus(t *testing.T) {
+	bid := &eth.ExecutionPayloadBid{
+		ParentBlockHash:        bytes.Repeat([]byte{0x01}, 32),
+		ParentBlockRoot:        bytes.Repeat([]byte{0x02}, 32),
+		BlockHash:              bytes.Repeat([]byte{0x03}, 32),
+		PrevRandao:             bytes.Repeat([]byte{0x04}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x05}, 20),
+		GasLimit:               100,
+		BuilderIndex:           7,
+		Slot:                   9,
+		Value:                  11,
+		ExecutionPayment:       22,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x06}, 32),
+	}
+	roBid, err := blocks.WrappedROExecutionPayloadBid(bid)
+	require.NoError(t, err)
+
+	got := ROExecutionPayloadBidFromConsensus(roBid)
+	want := &ExecutionPayloadBid{
+		ParentBlockHash:        hexutil.Encode(bid.ParentBlockHash),
+		ParentBlockRoot:        hexutil.Encode(bid.ParentBlockRoot),
+		BlockHash:              hexutil.Encode(bid.BlockHash),
+		PrevRandao:             hexutil.Encode(bid.PrevRandao),
+		FeeRecipient:           hexutil.Encode(bid.FeeRecipient),
+		GasLimit:               "100",
+		BuilderIndex:           "7",
+		Slot:                   "9",
+		Value:                  "11",
+		ExecutionPayment:       "22",
+		BlobKzgCommitmentsRoot: hexutil.Encode(bid.BlobKzgCommitmentsRoot),
+	}
+	assert.DeepEqual(t, want, got)
+}
+
+func TestBuilderConversionsFromConsensus(t *testing.T) {
+	builder := &eth.Builder{
+		Pubkey:            bytes.Repeat([]byte{0xAA}, 48),
+		Version:           bytes.Repeat([]byte{0x01}, 4),
+		ExecutionAddress:  bytes.Repeat([]byte{0xBB}, 20),
+		Balance:           42,
+		DepositEpoch:      3,
+		WithdrawableEpoch: 4,
+	}
+	wantBuilder := &Builder{
+		Pubkey:            hexutil.Encode(builder.Pubkey),
+		Version:           hexutil.Encode(builder.Version),
+		ExecutionAddress:  hexutil.Encode(builder.ExecutionAddress),
+		Balance:           "42",
+		DepositEpoch:      "3",
+		WithdrawableEpoch: "4",
+	}
+
+	assert.DeepEqual(t, wantBuilder, BuilderFromConsensus(builder))
+	assert.DeepEqual(t, []*Builder{wantBuilder}, BuildersFromConsensus([]*eth.Builder{builder}))
+}
+
+func TestBuilderPendingPaymentConversionsFromConsensus(t *testing.T) {
+	withdrawal := &eth.BuilderPendingWithdrawal{
+		FeeRecipient: bytes.Repeat([]byte{0x10}, 20),
+		Amount:       15,
+		BuilderIndex: 2,
+	}
+	payment := &eth.BuilderPendingPayment{
+		Weight:     5,
+		Withdrawal: withdrawal,
+	}
+	wantWithdrawal := &BuilderPendingWithdrawal{
+		FeeRecipient: hexutil.Encode(withdrawal.FeeRecipient),
+		Amount:       "15",
+		BuilderIndex: "2",
+	}
+	wantPayment := &BuilderPendingPayment{
+		Weight:     "5",
+		Withdrawal: wantWithdrawal,
+	}
+
+	assert.DeepEqual(t, wantPayment, BuilderPendingPaymentFromConsensus(payment))
+	assert.DeepEqual(t, []*BuilderPendingPayment{wantPayment}, BuilderPendingPaymentsFromConsensus([]*eth.BuilderPendingPayment{payment}))
+	assert.DeepEqual(t, wantWithdrawal, BuilderPendingWithdrawalFromConsensus(withdrawal))
+	assert.DeepEqual(t, []*BuilderPendingWithdrawal{wantWithdrawal}, BuilderPendingWithdrawalsFromConsensus([]*eth.BuilderPendingWithdrawal{withdrawal}))
+}
+
+func TestBeaconStateGloasFromConsensus(t *testing.T) {
+	st, err := util.NewBeaconStateGloas(func(state *eth.BeaconStateGloas) error {
+		state.GenesisTime = 123
+		state.GenesisValidatorsRoot = bytes.Repeat([]byte{0x10}, 32)
+		state.Slot = 5
+		state.ProposerLookahead = []uint64{1, 2}
+		state.LatestExecutionPayloadBid = &eth.ExecutionPayloadBid{
+			ParentBlockHash:        bytes.Repeat([]byte{0x11}, 32),
+			ParentBlockRoot:        bytes.Repeat([]byte{0x12}, 32),
+			BlockHash:              bytes.Repeat([]byte{0x13}, 32),
+			PrevRandao:             bytes.Repeat([]byte{0x14}, 32),
+			FeeRecipient:           bytes.Repeat([]byte{0x15}, 20),
+			GasLimit:               64,
+			BuilderIndex:           3,
+			Slot:                   5,
+			Value:                  99,
+			ExecutionPayment:       7,
+			BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x16}, 32),
+		}
+		state.Builders = []*eth.Builder{
+			{
+				Pubkey:            bytes.Repeat([]byte{0x20}, 48),
+				Version:           bytes.Repeat([]byte{0x21}, 4),
+				ExecutionAddress:  bytes.Repeat([]byte{0x22}, 20),
+				Balance:           88,
+				DepositEpoch:      1,
+				WithdrawableEpoch: 2,
+			},
+		}
+		state.NextWithdrawalBuilderIndex = 9
+		state.ExecutionPayloadAvailability = []byte{0x01, 0x02}
+		state.BuilderPendingPayments = []*eth.BuilderPendingPayment{
+			{
+				Weight: 3,
+				Withdrawal: &eth.BuilderPendingWithdrawal{
+					FeeRecipient: bytes.Repeat([]byte{0x23}, 20),
+					Amount:       4,
+					BuilderIndex: 5,
+				},
+			},
+		}
+		state.BuilderPendingWithdrawals = []*eth.BuilderPendingWithdrawal{
+			{
+				FeeRecipient: bytes.Repeat([]byte{0x24}, 20),
+				Amount:       6,
+				BuilderIndex: 7,
+			},
+		}
+		state.LatestBlockHash = bytes.Repeat([]byte{0x25}, 32)
+		state.PayloadExpectedWithdrawals = []*enginev1.Withdrawal{
+			{Index: 1, ValidatorIndex: 2, Address: bytes.Repeat([]byte{0x26}, 20), Amount: 10},
+		}
+		return nil
+	})
+	require.NoError(t, err)
+
+	got, err := BeaconStateGloasFromConsensus(st)
+	require.NoError(t, err)
+
+	require.Equal(t, "123", got.GenesisTime)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x10}, 32)), got.GenesisValidatorsRoot)
+	require.Equal(t, "5", got.Slot)
+	require.DeepEqual(t, []string{"1", "2"}, got.ProposerLookahead)
+	require.Equal(t, "9", got.NextWithdrawalBuilderIndex)
+	require.Equal(t, hexutil.Encode([]byte{0x01, 0x02}), got.ExecutionPayloadAvailability)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x25}, 32)), got.LatestBlockHash)
+
+	require.NotNil(t, got.LatestExecutionPayloadBid)
+	require.Equal(t, "64", got.LatestExecutionPayloadBid.GasLimit)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x11}, 32)), got.LatestExecutionPayloadBid.ParentBlockHash)
+
+	require.NotNil(t, got.Builders)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x20}, 48)), got.Builders[0].Pubkey)
+	require.Equal(t, "88", got.Builders[0].Balance)
+
+	require.Equal(t, "3", got.BuilderPendingPayments[0].Weight)
+	require.Equal(t, "4", got.BuilderPendingPayments[0].Withdrawal.Amount)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x23}, 20)), got.BuilderPendingPayments[0].Withdrawal.FeeRecipient)
+
+	require.Equal(t, "6", got.BuilderPendingWithdrawals[0].Amount)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x24}, 20)), got.BuilderPendingWithdrawals[0].FeeRecipient)
+
+	require.Equal(t, "1", got.PayloadExpectedWithdrawals[0].WithdrawalIndex)
+	require.Equal(t, "2", got.PayloadExpectedWithdrawals[0].ValidatorIndex)
+	require.Equal(t, hexutil.Encode(bytes.Repeat([]byte{0x26}, 20)), got.PayloadExpectedWithdrawals[0].ExecutionAddress)
+	require.Equal(t, "10", got.PayloadExpectedWithdrawals[0].Amount)
+}
+
 func TestIndexedAttestation_ToConsensus(t *testing.T) {
 	a := &IndexedAttestation{
 		AttestingIndices: []string{"1"},

api/server/structs/other.go

@@ -262,3 +262,23 @@ type PendingConsolidation struct {
 	SourceIndex string `json:"source_index"`
 	TargetIndex string `json:"target_index"`
 }
+
+type Builder struct {
+	Pubkey            string `json:"pubkey"`
+	Version           string `json:"version"`
+	ExecutionAddress  string `json:"execution_address"`
+	Balance           string `json:"balance"`
+	DepositEpoch      string `json:"deposit_epoch"`
+	WithdrawableEpoch string `json:"withdrawable_epoch"`
+}
+
+type BuilderPendingPayment struct {
+	Weight     string                    `json:"weight"`
+	Withdrawal *BuilderPendingWithdrawal `json:"withdrawal"`
+}
+
+type BuilderPendingWithdrawal struct {
+	FeeRecipient string `json:"fee_recipient"`
+	Amount       string `json:"amount"`
+	BuilderIndex string `json:"builder_index"`
+}

api/server/structs/state.go

@@ -221,3 +221,51 @@ type BeaconStateFulu struct {
 	PendingConsolidations         []*PendingConsolidation      `json:"pending_consolidations"`
 	ProposerLookahead             []string                     `json:"proposer_lookahead"`
 }
+
+type BeaconStateGloas struct {
+	GenesisTime                   string                      `json:"genesis_time"`
+	GenesisValidatorsRoot         string                      `json:"genesis_validators_root"`
+	Slot                          string                      `json:"slot"`
+	Fork                          *Fork                       `json:"fork"`
+	LatestBlockHeader             *BeaconBlockHeader          `json:"latest_block_header"`
+	BlockRoots                    []string                    `json:"block_roots"`
+	StateRoots                    []string                    `json:"state_roots"`
+	HistoricalRoots               []string                    `json:"historical_roots"`
+	Eth1Data                      *Eth1Data                   `json:"eth1_data"`
+	Eth1DataVotes                 []*Eth1Data                 `json:"eth1_data_votes"`
+	Eth1DepositIndex              string                      `json:"eth1_deposit_index"`
+	Validators                    []*Validator                `json:"validators"`
+	Balances                      []string                    `json:"balances"`
+	RandaoMixes                   []string                    `json:"randao_mixes"`
+	Slashings                     []string                    `json:"slashings"`
+	PreviousEpochParticipation    []string                    `json:"previous_epoch_participation"`
+	CurrentEpochParticipation     []string                    `json:"current_epoch_participation"`
+	JustificationBits             string                      `json:"justification_bits"`
+	PreviousJustifiedCheckpoint   *Checkpoint                 `json:"previous_justified_checkpoint"`
+	CurrentJustifiedCheckpoint    *Checkpoint                 `json:"current_justified_checkpoint"`
+	FinalizedCheckpoint           *Checkpoint                 `json:"finalized_checkpoint"`
+	InactivityScores              []string                    `json:"inactivity_scores"`
+	CurrentSyncCommittee          *SyncCommittee              `json:"current_sync_committee"`
+	NextSyncCommittee             *SyncCommittee              `json:"next_sync_committee"`
+	NextWithdrawalIndex           string                      `json:"next_withdrawal_index"`
+	NextWithdrawalValidatorIndex  string                      `json:"next_withdrawal_validator_index"`
+	HistoricalSummaries           []*HistoricalSummary        `json:"historical_summaries"`
+	DepositRequestsStartIndex     string                      `json:"deposit_requests_start_index"`
+	DepositBalanceToConsume       string                      `json:"deposit_balance_to_consume"`
+	ExitBalanceToConsume          string                      `json:"exit_balance_to_consume"`
+	EarliestExitEpoch             string                      `json:"earliest_exit_epoch"`
+	ConsolidationBalanceToConsume string                      `json:"consolidation_balance_to_consume"`
+	EarliestConsolidationEpoch    string                      `json:"earliest_consolidation_epoch"`
+	PendingDeposits               []*PendingDeposit           `json:"pending_deposits"`
+	PendingPartialWithdrawals     []*PendingPartialWithdrawal `json:"pending_partial_withdrawals"`
+	PendingConsolidations         []*PendingConsolidation     `json:"pending_consolidations"`
+	ProposerLookahead             []string                    `json:"proposer_lookahead"`
+	LatestExecutionPayloadBid     *ExecutionPayloadBid        `json:"latest_execution_payload_bid"`
+	Builders                      []*Builder                  `json:"builders"`
+	NextWithdrawalBuilderIndex    string                      `json:"next_withdrawal_builder_index"`
+	ExecutionPayloadAvailability  string                      `json:"execution_payload_availability"`
+	BuilderPendingPayments        []*BuilderPendingPayment    `json:"builder_pending_payments"`
+	BuilderPendingWithdrawals     []*BuilderPendingWithdrawal `json:"builder_pending_withdrawals"`
+	LatestBlockHash               string                      `json:"latest_block_hash"`
+	PayloadExpectedWithdrawals    []*Withdrawal               `json:"payload_expected_withdrawals"`
+}

beacon-chain/blockchain/BUILD.bazel

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

beacon-chain/blockchain/log_helpers.go

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

beacon-chain/core/gloas/BUILD.bazel

@@ -4,6 +4,9 @@ go_library(
     name = "go_default_library",
     srcs = [
         "bid.go",
+        "deposit_request.go",
+        "log.go",
+        "payload.go",
         "payload_attestation.go",
         "pending_payment.go",
         "proposer_slashing.go",
@@ -12,6 +15,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -25,9 +29,13 @@ go_library(
         "//crypto/bls/common:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )
 
@@ -35,7 +43,9 @@ go_test(
     name = "go_default_test",
     srcs = [
         "bid_test.go",
+        "deposit_request_test.go",
         "payload_attestation_test.go",
+        "payload_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",
     ],
@@ -45,6 +55,7 @@ go_test(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/testing:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
@@ -52,6 +63,7 @@ go_test(
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",

beacon-chain/core/gloas/bid.go

@@ -17,56 +17,27 @@ import (
 )
 
 // ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// process_execution_payload_bid(state: BeaconState, block: BeaconBlock):
 //
-//	<spec fn="process_execution_payload_bid" fork="gloas" hash="823c9f3a">
-//	def process_execution_payload_bid(state: BeaconState, block: BeaconBlock) -> None:
-//	    signed_bid = block.body.signed_execution_payload_bid
-//	    bid = signed_bid.message
-//	    builder_index = bid.builder_index
-//	    amount = bid.value
-//
-//	    # For self-builds, amount must be zero regardless of withdrawal credential prefix
-//	    if builder_index == BUILDER_INDEX_SELF_BUILD:
-//	        assert amount == 0
-//	        assert signed_bid.signature == bls.G2_POINT_AT_INFINITY
-//	    else:
-//	        # Verify that the builder is active
-//	        assert is_active_builder(state, builder_index)
-//	        # Verify that the builder has funds to cover the bid
-//	        assert can_builder_cover_bid(state, builder_index, amount)
-//	        # Verify that the bid signature is valid
-//	        assert verify_execution_payload_bid_signature(state, signed_bid)
-//
-//	    # Verify commitments are under limit
-//	    assert (
-//	        len(bid.blob_kzg_commitments)
-//	        <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
-//	    )
-//
-//	    # Verify that the bid is for the current slot
-//	    assert bid.slot == block.slot
-//	    # Verify that the bid is for the right parent block
-//	    assert bid.parent_block_hash == state.latest_block_hash
-//	    assert bid.parent_block_root == block.parent_root
-//	    assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
-//
-//	    # Record the pending payment if there is some payment
-//	    if amount > 0:
-//	        pending_payment = BuilderPendingPayment(
-//	            weight=0,
-//	            withdrawal=BuilderPendingWithdrawal(
-//	                fee_recipient=bid.fee_recipient,
-//	                amount=amount,
-//	                builder_index=builder_index,
-//	            ),
-//	        )
-//	        state.builder_pending_payments[SLOTS_PER_EPOCH + bid.slot % SLOTS_PER_EPOCH] = (
-//	            pending_payment
-//	        )
-//
-//	    # Cache the signed execution payload bid
-//	    state.latest_execution_payload_bid = bid
-//	</spec>
+//	signed_bid = block.body.signed_execution_payload_bid
+//	bid = signed_bid.message
+//	builder_index = bid.builder_index
+//	amount = bid.value
+//	if builder_index == BUILDER_INDEX_SELF_BUILD:
+//	  assert amount == 0
+//	  assert signed_bid.signature == G2_POINT_AT_INFINITY
+//	else:
+//	  assert is_active_builder(state, builder_index)
+//	  assert can_builder_cover_bid(state, builder_index, amount)
+//	  assert verify_execution_payload_bid_signature(state, signed_bid)
+//	assert bid.slot == block.slot
+//	assert bid.parent_block_hash == state.latest_block_hash
+//	assert bid.parent_block_root == block.parent_root
+//	assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
+//	if amount > 0:
+//	  state.builder_pending_payments[...] = BuilderPendingPayment(weight=0, withdrawal=BuilderPendingWithdrawal(fee_recipient=bid.fee_recipient, amount=amount, builder_index=builder_index))
+//	state.latest_execution_payload_bid = bid
 func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) error {
 	signedBid, err := block.Body().SignedExecutionPayloadBid()
 	if err != nil {
@@ -115,12 +86,6 @@ func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyB
 		}
 	}
 
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlockAtEpoch(slots.ToEpoch(block.Slot()))
-	commitmentCount := bid.BlobKzgCommitmentCount()
-	if commitmentCount > uint64(maxBlobsPerBlock) {
-		return fmt.Errorf("bid has %d blob KZG commitments over max %d", commitmentCount, maxBlobsPerBlock)
-	}
-
 	if err := validateBidConsistency(st, bid, block); err != nil {
 		return errors.Wrap(err, "bid consistency validation failed")
 	}

beacon-chain/core/gloas/bid_test.go

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

beacon-chain/core/gloas/deposit_request.go

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

beacon-chain/core/gloas/deposit_request_test.go

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

beacon-chain/core/gloas/log.go

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

beacon-chain/core/gloas/payload.go

@@ -0,0 +1,330 @@
+package gloas
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	requests "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+)
+
+// ProcessExecutionPayload processes the signed execution payload envelope for the Gloas fork.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def process_execution_payload(
+//
+//	state: BeaconState,
+//	signed_envelope: SignedExecutionPayloadEnvelope,
+//	execution_engine: ExecutionEngine,
+//	verify: bool = True,
+//
+// ) -> None:
+//
+//	envelope = signed_envelope.message
+//	payload = envelope.payload
+//
+//	if verify:
+//	    assert verify_execution_payload_envelope_signature(state, signed_envelope)
+//
+//	previous_state_root = hash_tree_root(state)
+//	if state.latest_block_header.state_root == Root():
+//	    state.latest_block_header.state_root = previous_state_root
+//
+//	assert envelope.beacon_block_root == hash_tree_root(state.latest_block_header)
+//	assert envelope.slot == state.slot
+//
+//	committed_bid = state.latest_execution_payload_bid
+//	assert envelope.builder_index == committed_bid.builder_index
+//	assert committed_bid.blob_kzg_commitments_root == hash_tree_root(envelope.blob_kzg_commitments)
+//	assert committed_bid.prev_randao == payload.prev_randao
+//
+//	assert hash_tree_root(payload.withdrawals) == hash_tree_root(state.payload_expected_withdrawals)
+//
+//	assert committed_bid.gas_limit == payload.gas_limit
+//	assert committed_bid.block_hash == payload.block_hash
+//	assert payload.parent_hash == state.latest_block_hash
+//	assert payload.timestamp == compute_time_at_slot(state, state.slot)
+//	assert (
+//	    len(envelope.blob_kzg_commitments)
+//	    <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
+//	)
+//	versioned_hashes = [
+//	    kzg_commitment_to_versioned_hash(commitment) for commitment in envelope.blob_kzg_commitments
+//	]
+//	requests = envelope.execution_requests
+//	assert execution_engine.verify_and_notify_new_payload(
+//	    NewPayloadRequest(
+//	        execution_payload=payload,
+//	        versioned_hashes=versioned_hashes,
+//	        parent_beacon_block_root=state.latest_block_header.parent_root,
+//	        execution_requests=requests,
+//	    )
+//	)
+//
+//	for op in requests.deposits: process_deposit_request(state, op)
+//	for op in requests.withdrawals: process_withdrawal_request(state, op)
+//	for op in requests.consolidations: process_consolidation_request(state, op)
+//
+//	payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
+//	amount = payment.withdrawal.amount
+//	if amount > 0:
+//	    state.builder_pending_withdrawals.append(payment.withdrawal)
+//	state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = (
+//	    BuilderPendingPayment()
+//	)
+//
+//	state.execution_payload_availability[state.slot % SLOTS_PER_HISTORICAL_ROOT] = 0b1
+//	state.latest_block_hash = payload.block_hash
+//
+//	if verify:
+//	    assert envelope.state_root == hash_tree_root(state)
+func ProcessExecutionPayload(
+	ctx context.Context,
+	st state.BeaconState,
+	signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope,
+) error {
+	if err := verifyExecutionPayloadEnvelopeSignature(st, signedEnvelope); err != nil {
+		return errors.Wrap(err, "signature verification failed")
+	}
+
+	latestHeader := st.LatestBlockHeader()
+	if len(latestHeader.StateRoot) == 0 || bytes.Equal(latestHeader.StateRoot, make([]byte, 32)) {
+		previousStateRoot, err := st.HashTreeRoot(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not compute state root")
+		}
+		latestHeader.StateRoot = previousStateRoot[:]
+		if err := st.SetLatestBlockHeader(latestHeader); err != nil {
+			return errors.Wrap(err, "could not set latest block header")
+		}
+	}
+
+	blockHeaderRoot, err := latestHeader.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not compute block header root")
+	}
+	envelope, err := signedEnvelope.Envelope()
+	if err != nil {
+		return errors.Wrap(err, "could not get envelope from signed envelope")
+	}
+	beaconBlockRoot := envelope.BeaconBlockRoot()
+	if !bytes.Equal(beaconBlockRoot[:], blockHeaderRoot[:]) {
+		return errors.Errorf("envelope beacon block root does not match state latest block header root: envelope=%#x, header=%#x", beaconBlockRoot, blockHeaderRoot)
+	}
+
+	if envelope.Slot() != st.Slot() {
+		return errors.Errorf("envelope slot does not match state slot: envelope=%d, state=%d", envelope.Slot(), st.Slot())
+	}
+
+	latestBid, err := st.LatestExecutionPayloadBid()
+	if err != nil {
+		return errors.Wrap(err, "could not get latest execution payload bid")
+	}
+	if latestBid == nil {
+		return errors.New("latest execution payload bid is nil")
+	}
+	if envelope.BuilderIndex() != latestBid.BuilderIndex() {
+		return errors.Errorf("envelope builder index does not match committed bid builder index: envelope=%d, bid=%d", envelope.BuilderIndex(), latestBid.BuilderIndex())
+	}
+
+	envelopeBlobCommitments := envelope.BlobKzgCommitments()
+	envelopeBlobRoot, err := ssz.KzgCommitmentsRoot(envelopeBlobCommitments)
+	if err != nil {
+		return errors.Wrap(err, "could not compute envelope blob KZG commitments root")
+	}
+	committedBlobRoot := latestBid.BlobKzgCommitmentsRoot()
+	if !bytes.Equal(committedBlobRoot[:], envelopeBlobRoot[:]) {
+		return errors.Errorf("committed bid blob KZG commitments root does not match envelope: bid=%#x, envelope=%#x", committedBlobRoot, envelopeBlobRoot)
+	}
+
+	payload, err := envelope.Execution()
+	if err != nil {
+		return errors.Wrap(err, "could not get execution payload from envelope")
+	}
+	withdrawals, err := payload.Withdrawals()
+	if err != nil {
+		return errors.Wrap(err, "could not get withdrawals from payload")
+	}
+
+	ok, err := st.WithdrawalsMatchPayloadExpected(withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not validate payload withdrawals")
+	}
+	if !ok {
+		return errors.New("payload withdrawals do not match expected withdrawals")
+	}
+
+	if latestBid.GasLimit() != payload.GasLimit() {
+		return errors.Errorf("committed bid gas limit does not match payload gas limit: bid=%d, payload=%d", latestBid.GasLimit(), payload.GasLimit())
+	}
+
+	latestBidPrevRandao := latestBid.PrevRandao()
+	if !bytes.Equal(payload.PrevRandao(), latestBidPrevRandao[:]) {
+		return errors.Errorf("payload prev randao does not match committed bid prev randao: payload=%#x, bid=%#x", payload.PrevRandao(), latestBidPrevRandao)
+	}
+
+	bidBlockHash := latestBid.BlockHash()
+	payloadBlockHash := payload.BlockHash()
+	if !bytes.Equal(bidBlockHash[:], payloadBlockHash) {
+		return errors.Errorf("committed bid block hash does not match payload block hash: bid=%#x, payload=%#x", bidBlockHash, payloadBlockHash)
+	}
+
+	latestBlockHash, err := st.LatestBlockHash()
+	if err != nil {
+		return errors.Wrap(err, "could not get latest block hash")
+	}
+	if !bytes.Equal(payload.ParentHash(), latestBlockHash[:]) {
+		return errors.Errorf("payload parent hash does not match state latest block hash: payload=%#x, state=%#x", payload.ParentHash(), latestBlockHash)
+	}
+
+	t, err := slots.StartTime(st.GenesisTime(), st.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not compute timestamp")
+	}
+	if payload.Timestamp() != uint64(t.Unix()) {
+		return errors.Errorf("payload timestamp does not match expected timestamp: payload=%d, expected=%d", payload.Timestamp(), uint64(t.Unix()))
+	}
+
+	cfg := params.BeaconConfig()
+	maxBlobsPerBlock := cfg.MaxBlobsPerBlock(envelope.Slot())
+	if len(envelopeBlobCommitments) > maxBlobsPerBlock {
+		return errors.Errorf("too many blob KZG commitments: got=%d, max=%d", len(envelopeBlobCommitments), maxBlobsPerBlock)
+	}
+
+	if err := processExecutionRequests(ctx, st, envelope.ExecutionRequests()); err != nil {
+		return errors.Wrap(err, "could not process execution requests")
+	}
+
+	if err := st.QueueBuilderPayment(); err != nil {
+		return errors.Wrap(err, "could not queue builder payment")
+	}
+
+	if err := st.SetExecutionPayloadAvailability(st.Slot(), true); err != nil {
+		return errors.Wrap(err, "could not set execution payload availability")
+	}
+
+	if err := st.SetLatestBlockHash([32]byte(payload.BlockHash())); err != nil {
+		return errors.Wrap(err, "could not set latest block hash")
+	}
+
+	r, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get hash tree root")
+	}
+	if r != envelope.StateRoot() {
+		return fmt.Errorf("state root mismatch: expected %#x, got %#x", envelope.StateRoot(), r)
+	}
+
+	return nil
+}
+
+// processExecutionRequests processes deposits, withdrawals, and consolidations from execution requests.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// for op in requests.deposits: process_deposit_request(state, op)
+// for op in requests.withdrawals: process_withdrawal_request(state, op)
+// for op in requests.consolidations: process_consolidation_request(state, op)
+func processExecutionRequests(ctx context.Context, st state.BeaconState, rqs *enginev1.ExecutionRequests) error {
+	if err := processDepositRequests(ctx, st, rqs.Deposits); err != nil {
+		return errors.Wrap(err, "could not process deposit requests")
+	}
+
+	var err error
+	st, err = requests.ProcessWithdrawalRequests(ctx, st, rqs.Withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not process withdrawal requests")
+	}
+	err = requests.ProcessConsolidationRequests(ctx, st, rqs.Consolidations)
+	if err != nil {
+		return errors.Wrap(err, "could not process consolidation requests")
+	}
+	return nil
+}
+
+// verifyExecutionPayloadEnvelopeSignature verifies the BLS signature on a signed execution payload envelope.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// builder_index = signed_envelope.message.builder_index
+// if builder_index == BUILDER_INDEX_SELF_BUILD:
+//
+//	validator_index = state.latest_block_header.proposer_index
+//	pubkey = state.validators[validator_index].pubkey
+//
+// else:
+//
+//	pubkey = state.builders[builder_index].pubkey
+//
+// signing_root = compute_signing_root(
+//
+//	signed_envelope.message, get_domain(state, DOMAIN_BEACON_BUILDER)
+//
+// )
+// return bls.Verify(pubkey, signing_root, signed_envelope.signature)
+func verifyExecutionPayloadEnvelopeSignature(st state.BeaconState, signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope) error {
+	envelope, err := signedEnvelope.Envelope()
+	if err != nil {
+		return fmt.Errorf("failed to get envelope: %w", err)
+	}
+
+	builderIdx := envelope.BuilderIndex()
+	var publicKey bls.PublicKey
+	if builderIdx == params.BeaconConfig().BuilderIndexSelfBuild {
+		header := st.LatestBlockHeader()
+		if header == nil {
+			return fmt.Errorf("latest block header is nil")
+		}
+		proposerPubkey := st.PubkeyAtIndex(header.ProposerIndex)
+		key, err := bls.PublicKeyFromBytes(proposerPubkey[:])
+		if err != nil {
+			return fmt.Errorf("invalid proposer public key: %w", err)
+		}
+		publicKey = key
+	} else {
+		builder, err := st.Builder(builderIdx)
+		if err != nil {
+			return fmt.Errorf("failed to get builder: %w", err)
+		}
+		if builder == nil {
+			return fmt.Errorf("builder at index %d not found", builderIdx)
+		}
+		key, err := bls.PublicKeyFromBytes(builder.Pubkey)
+		if err != nil {
+			return fmt.Errorf("invalid builder public key: %w", err)
+		}
+		publicKey = key
+	}
+
+	signatureBytes := signedEnvelope.Signature()
+	signature, err := bls.SignatureFromBytes(signatureBytes[:])
+	if err != nil {
+		return fmt.Errorf("invalid signature format: %w", err)
+	}
+
+	currentEpoch := slots.ToEpoch(envelope.Slot())
+	domain, err := signing.Domain(
+		st.Fork(),
+		currentEpoch,
+		params.BeaconConfig().DomainBeaconBuilder,
+		st.GenesisValidatorsRoot(),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to compute signing domain: %w", err)
+	}
+
+	signingRoot, err := signedEnvelope.SigningRoot(domain)
+	if err != nil {
+		return fmt.Errorf("failed to compute signing root: %w", err)
+	}
+
+	if !signature.Verify(publicKey, signingRoot[:]) {
+		return fmt.Errorf("signature verification failed: %w", signing.ErrSigFailedToVerify)
+	}
+
+	return nil
+}

beacon-chain/core/gloas/payload_attestation.go

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

beacon-chain/core/gloas/payload_test.go

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

beacon-chain/core/gloas/pending_payment.go

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

beacon-chain/core/gloas/proposer_slashing.go

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

beacon-chain/core/transition/transition.go

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

beacon-chain/core/transition/transition_gloas_test.go

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

beacon-chain/db/kv/archived_point.go

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

beacon-chain/db/kv/blocks.go

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

beacon-chain/db/kv/custody_test.go

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

beacon-chain/db/kv/deposit_contract.go

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

beacon-chain/db/kv/migration_state_validators.go

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

beacon-chain/db/kv/state_diff.go

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

beacon-chain/db/kv/state_summary.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

beacon-chain/forkchoice/interfaces.go

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

beacon-chain/forkchoice/ro.go

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

beacon-chain/forkchoice/ro_test.go

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

beacon-chain/node/node.go

@@ -134,20 +134,10 @@ type BeaconNode struct {
 
 // New creates a new node instance, sets up configuration options, and registers
 // every required service to the node.
-func New(cliCtx *cli.Context, cancel context.CancelFunc, optFuncs []func(*cli.Context) ([]Option, error), opts ...Option) (*BeaconNode, error) {
+func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*BeaconNode, error) {
 	if err := configureBeacon(cliCtx); err != nil {
 		return nil, errors.Wrap(err, "could not set beacon configuration options")
 	}
-
-	for _, of := range optFuncs {
-		ofo, err := of(cliCtx)
-		if err != nil {
-			return nil, err
-		}
-		if ofo != nil {
-			opts = append(opts, ofo...)
-		}
-	}
 	ctx := cliCtx.Context
 
 	beacon := &BeaconNode{

beacon-chain/node/node_test.go

@@ -59,7 +59,7 @@ func TestNodeClose_OK(t *testing.T) {
 		WithDataColumnStorage(filesystem.NewEphemeralDataColumnStorage(t)),
 	}
 
-	node, err := New(ctx, cancel, nil, options...)
+	node, err := New(ctx, cancel, options...)
 	require.NoError(t, err)
 
 	node.Close()
@@ -87,7 +87,7 @@ func TestNodeStart_Ok(t *testing.T) {
 		WithDataColumnStorage(filesystem.NewEphemeralDataColumnStorage(t)),
 	}
 
-	node, err := New(ctx, cancel, nil, options...)
+	node, err := New(ctx, cancel, options...)
 	require.NoError(t, err)
 	require.NotNil(t, node.lcStore)
 	node.services = &runtime.ServiceRegistry{}
@@ -116,7 +116,7 @@ func TestNodeStart_SyncChecker(t *testing.T) {
 		WithDataColumnStorage(filesystem.NewEphemeralDataColumnStorage(t)),
 	}
 
-	node, err := New(ctx, cancel, nil, options...)
+	node, err := New(ctx, cancel, options...)
 	require.NoError(t, err)
 	go func() {
 		node.Start()
@@ -151,7 +151,7 @@ func TestClearDB(t *testing.T) {
 		WithDataColumnStorage(filesystem.NewEphemeralDataColumnStorage(t)),
 	}
 
-	_, err = New(context, cancel, nil, options...)
+	_, err = New(context, cancel, options...)
 	require.NoError(t, err)
 	require.LogsContain(t, hook, "Removing database")
 }

beacon-chain/p2p/testing/p2p.go

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

beacon-chain/rpc/eth/beacon/handlers.go

@@ -163,11 +163,7 @@ func (s *Server) GetBlockV2(w http.ResponseWriter, r *http.Request) {
 	if blk.Version() >= version.Bellatrix && blk.IsBlinded() {
 		blk, err = s.ExecutionReconstructor.ReconstructFullBlock(ctx, blk)
 		if err != nil {
-			if errors.Is(err, blocks.ErrNonCanonicalBlock) {
-				httputil.HandleError(w, fmt.Sprintf("no canonical block found for block %s: execution payload is unavailable (block may have been orphaned)", blockId), http.StatusNotFound)
-			} else {
-				httputil.HandleError(w, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block").Error(), http.StatusInternalServerError)
-			}
+			httputil.HandleError(w, errors.Wrapf(err, "could not reconstruct full execution payload to create signed beacon block").Error(), http.StatusBadRequest)
 			return
 		}
 	}

beacon-chain/rpc/eth/beacon/handlers_pool_test.go

@@ -26,8 +26,8 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/voluntaryexits/mock"
 	p2pMock "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/core"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	mockSync "github.com/OffchainLabs/prysm/v7/beacon-chain/sync/initial-sync/testing"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"

beacon-chain/rpc/eth/config/handlers_test.go

@@ -86,6 +86,7 @@ func TestGetSpec(t *testing.T) {
 	config.GloasForkEpoch = 110
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
+	config.BuilderWithdrawalPrefixByte = byte('e')
 	config.GenesisDelay = 24
 	config.SecondsPerSlot = 25
 	config.SlotDurationMilliseconds = 120

beacon-chain/rpc/prysm/v1alpha1/node/BUILD.bazel

@@ -48,7 +48,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//reflection:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",

beacon-chain/rpc/prysm/v1alpha1/node/server.go

@@ -35,19 +35,18 @@ import (
 // providing RPC endpoints for verifying a beacon node's sync status, genesis and
 // version information, and services the node implements and runs.
 type Server struct {
-	LogsStreamer          logs.Streamer
-	StreamLogsBufferSize  int
-	SyncChecker           sync.Checker
-	Server                *grpc.Server
-	BeaconDB              db.ReadOnlyDatabase
-	PeersFetcher          p2p.PeersProvider
-	PeerManager           p2p.PeerManager
-	GenesisTimeFetcher    blockchain.TimeFetcher
-	GenesisFetcher        blockchain.GenesisFetcher
-	POWChainInfoFetcher   execution.ChainInfoFetcher
-	BeaconMonitoringHost  string
-	BeaconMonitoringPort  int
-	OptimisticModeFetcher blockchain.OptimisticModeFetcher
+	LogsStreamer         logs.Streamer
+	StreamLogsBufferSize int
+	SyncChecker          sync.Checker
+	Server               *grpc.Server
+	BeaconDB             db.ReadOnlyDatabase
+	PeersFetcher         p2p.PeersProvider
+	PeerManager          p2p.PeerManager
+	GenesisTimeFetcher   blockchain.TimeFetcher
+	GenesisFetcher       blockchain.GenesisFetcher
+	POWChainInfoFetcher  execution.ChainInfoFetcher
+	BeaconMonitoringHost string
+	BeaconMonitoringPort int
 }
 
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
@@ -62,28 +61,21 @@ func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (
 	ctx, cancel := context.WithTimeout(ctx, timeoutDuration)
 	defer cancel() // Important to avoid a context leak
 
-	// Check optimistic status - validators should not participate when optimistic
-	isOptimistic, err := ns.OptimisticModeFetcher.IsOptimistic(ctx)
-	if err != nil {
-		return &empty.Empty{}, status.Errorf(codes.Internal, "Could not check optimistic status: %v", err)
-	}
-
-	if ns.SyncChecker.Synced() && !isOptimistic {
+	if ns.SyncChecker.Synced() {
 		return &empty.Empty{}, nil
 	}
 	if ns.SyncChecker.Syncing() || ns.SyncChecker.Initialized() {
-		// Set header for REST API clients (via gRPC-gateway)
-		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
-			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status code header: %v", err)
+		if request.SyncingStatus != 0 {
+			// override the 200 success with the provided request status
+			if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(request.SyncingStatus, 10))); err != nil {
+				return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
+			}
+			return &empty.Empty{}, nil
 		}
-		return &empty.Empty{}, status.Error(codes.Unavailable, "node is syncing")
-	}
-	if isOptimistic {
-		// Set header for REST API clients (via gRPC-gateway)
 		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
-			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status code header: %v", err)
+			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
 		}
-		return &empty.Empty{}, status.Error(codes.Unavailable, "node is optimistic")
+		return &empty.Empty{}, nil
 	}
 	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
 }

beacon-chain/rpc/prysm/v1alpha1/node/server_test.go

@@ -2,7 +2,6 @@ package node
 
 import (
 	"errors"
-	"maps"
 	"testing"
 	"time"
 
@@ -22,7 +21,6 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -189,71 +187,32 @@ func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {
 	assert.Equal(t, errStr, res.CurrentConnectionError)
 }
 
-// mockServerTransportStream implements grpc.ServerTransportStream for testing
-type mockServerTransportStream struct {
-	headers map[string][]string
-}
-
-func (m *mockServerTransportStream) Method() string { return "" }
-func (m *mockServerTransportStream) SetHeader(md metadata.MD) error {
-	maps.Copy(m.headers, md)
-	return nil
-}
-func (m *mockServerTransportStream) SendHeader(metadata.MD) error { return nil }
-func (m *mockServerTransportStream) SetTrailer(metadata.MD) error { return nil }
-
 func TestNodeServer_GetHealth(t *testing.T) {
 	tests := []struct {
 		name         string
 		input        *mockSync.Sync
-		isOptimistic bool
+		customStatus uint64
 		wantedErr    string
 	}{
 		{
-			name:         "happy path - synced and not optimistic",
-			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
-			isOptimistic: false,
+			name:  "happy path",
+			input: &mockSync.Sync{IsSyncing: false, IsSynced: true},
 		},
 		{
-			name:         "returns error when not synced and not syncing",
-			input:        &mockSync.Sync{IsSyncing: false, IsSynced: false},
-			isOptimistic: false,
-			wantedErr:    "service unavailable",
-		},
-		{
-			name:         "returns error when syncing",
-			input:        &mockSync.Sync{IsSyncing: true, IsSynced: false},
-			isOptimistic: false,
-			wantedErr:    "node is syncing",
-		},
-		{
-			name:         "returns error when synced but optimistic",
-			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
-			isOptimistic: true,
-			wantedErr:    "node is optimistic",
-		},
-		{
-			name:         "returns error when syncing and optimistic",
-			input:        &mockSync.Sync{IsSyncing: true, IsSynced: false},
-			isOptimistic: true,
-			wantedErr:    "node is syncing",
+			name:      "syncing",
+			input:     &mockSync.Sync{IsSyncing: false},
+			wantedErr: "service unavailable",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			server := grpc.NewServer()
 			ns := &Server{
-				SyncChecker:           tt.input,
-				OptimisticModeFetcher: &mock.ChainService{Optimistic: tt.isOptimistic},
+				SyncChecker: tt.input,
 			}
 			ethpb.RegisterNodeServer(server, ns)
 			reflection.Register(server)
-
-			// Create context with mock transport stream so grpc.SetHeader works
-			stream := &mockServerTransportStream{headers: make(map[string][]string)}
-			ctx := grpc.NewContextWithServerTransportStream(t.Context(), stream)
-
-			_, err := ns.GetHealth(ctx, &ethpb.HealthRequest{})
+			_, err := ns.GetHealth(t.Context(), &ethpb.HealthRequest{SyncingStatus: tt.customStatus})
 			if tt.wantedErr == "" {
 				require.NoError(t, err)
 				return

beacon-chain/rpc/service.go

@@ -259,19 +259,18 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 	}
 	s.validatorServer = validatorServer
 	nodeServer := &nodev1alpha1.Server{
-		LogsStreamer:          logs.NewStreamServer(),
-		StreamLogsBufferSize:  1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
-		BeaconDB:              s.cfg.BeaconDB,
-		Server:                s.grpcServer,
-		SyncChecker:           s.cfg.SyncService,
-		GenesisTimeFetcher:    s.cfg.GenesisTimeFetcher,
-		PeersFetcher:          s.cfg.PeersFetcher,
-		PeerManager:           s.cfg.PeerManager,
-		GenesisFetcher:        s.cfg.GenesisFetcher,
-		POWChainInfoFetcher:   s.cfg.ExecutionChainInfoFetcher,
-		BeaconMonitoringHost:  s.cfg.BeaconMonitoringHost,
-		BeaconMonitoringPort:  s.cfg.BeaconMonitoringPort,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+		LogsStreamer:         logs.NewStreamServer(),
+		StreamLogsBufferSize: 1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
+		BeaconDB:             s.cfg.BeaconDB,
+		Server:               s.grpcServer,
+		SyncChecker:          s.cfg.SyncService,
+		GenesisTimeFetcher:   s.cfg.GenesisTimeFetcher,
+		PeersFetcher:         s.cfg.PeersFetcher,
+		PeerManager:          s.cfg.PeerManager,
+		GenesisFetcher:       s.cfg.GenesisFetcher,
+		POWChainInfoFetcher:  s.cfg.ExecutionChainInfoFetcher,
+		BeaconMonitoringHost: s.cfg.BeaconMonitoringHost,
+		BeaconMonitoringPort: s.cfg.BeaconMonitoringPort,
 	}
 	beaconChainServer := &beaconv1alpha1.Server{
 		Ctx:                         s.ctx,

beacon-chain/state/interfaces_gloas.go

@@ -1,24 +1,56 @@
 package state
 
 import (
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
 type writeOnlyGloasFields interface {
+	// Bids.
 	SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error
+
+	// Builder pending payments / withdrawals.
 	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
 	ClearBuilderPendingPayment(index primitives.Slot) error
+	QueueBuilderPayment() error
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
+
+	// Execution payload availability.
 	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
+
+	// Misc.
+	SetLatestBlockHash(hash [32]byte) error
+	SetExecutionPayloadAvailability(index primitives.Slot, available bool) error
+
+	// Builders.
+	IncreaseBuilderBalance(index primitives.BuilderIndex, amount uint64) error
+	AddBuilderFromDeposit(pubkey [fieldparams.BLSPubkeyLength]byte, withdrawalCredentials [fieldparams.RootLength]byte, amount uint64) error
 }
 
 type readOnlyGloasFields interface {
+	// Bids.
+	LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error)
+
+	// Builder pending payments / withdrawals.
+	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
+	WithdrawalsMatchPayloadExpected(withdrawals []*enginev1.Withdrawal) (bool, error)
+	BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error)
+	PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error)
+
+	// Misc.
+	LatestBlockHash() ([32]byte, error)
+	ExecutionPayloadAvailability() ([]byte, error)
+
+	// Builders.
+	Builder(index primitives.BuilderIndex) (*ethpb.Builder, error)
+	Builders() ([]*ethpb.Builder, error)
 	BuilderPubkey(primitives.BuilderIndex) ([48]byte, error)
+	BuilderIndexByPubkey(pubkey [fieldparams.BLSPubkeyLength]byte) (primitives.BuilderIndex, bool)
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
-	LatestBlockHash() ([32]byte, error)
-	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
+	NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error)
 }

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

@@ -1,11 +1,16 @@
 package state_native
 
 import (
+	"bytes"
 	"fmt"
 
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 )
@@ -46,20 +51,14 @@ func (b *BeaconState) BuilderPubkey(builderIndex primitives.BuilderIndex) ([fiel
 }
 
 // IsActiveBuilder returns true if the builder placement is finalized and it has not initiated exit.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def is_active_builder(state: BeaconState, builder_index: BuilderIndex) -> bool:
 //
-//	<spec fn="is_active_builder" fork="gloas" hash="1a599fb2">
-//	def is_active_builder(state: BeaconState, builder_index: BuilderIndex) -> bool:
-//	    """
-//	    Check if the builder at ``builder_index`` is active for the given ``state``.
-//	    """
-//	    builder = state.builders[builder_index]
-//	    return (
-//	        # Placement in builder list is finalized
-//	        builder.deposit_epoch < state.finalized_checkpoint.epoch
-//	        # Has not initiated exit
-//	        and builder.withdrawable_epoch == FAR_FUTURE_EPOCH
-//	    )
-//	</spec>
+//	builder = state.builders[builder_index]
+//	return (
+//	    builder.deposit_epoch < state.finalized_checkpoint.epoch
+//	    and builder.withdrawable_epoch == FAR_FUTURE_EPOCH
+//	)
 func (b *BeaconState) IsActiveBuilder(builderIndex primitives.BuilderIndex) (bool, error) {
 	if b.version < version.Gloas {
 		return false, errNotSupported("IsActiveBuilder", b.version)
@@ -78,18 +77,15 @@ func (b *BeaconState) IsActiveBuilder(builderIndex primitives.BuilderIndex) (boo
 }
 
 // CanBuilderCoverBid returns true if the builder has enough balance to cover the given bid amount.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def can_builder_cover_bid(state: BeaconState, builder_index: BuilderIndex, bid_amount: Gwei) -> bool:
 //
-//	<spec fn="can_builder_cover_bid" fork="gloas" hash="9e3f2d7c">
-//	def can_builder_cover_bid(
-//	    state: BeaconState, builder_index: BuilderIndex, bid_amount: Gwei
-//	) -> bool:
-//	    builder_balance = state.builders[builder_index].balance
-//	    pending_withdrawals_amount = get_pending_balance_to_withdraw_for_builder(state, builder_index)
-//	    min_balance = MIN_DEPOSIT_AMOUNT + pending_withdrawals_amount
-//	    if builder_balance < min_balance:
-//	        return False
-//	    return builder_balance - min_balance >= bid_amount
-//	</spec>
+//	builder_balance = state.builders[builder_index].balance
+//	pending_withdrawals_amount = get_pending_balance_to_withdraw_for_builder(state, builder_index)
+//	min_balance = MIN_DEPOSIT_AMOUNT + pending_withdrawals_amount
+//	if builder_balance < min_balance:
+//	    return False
+//	return builder_balance - min_balance >= bid_amount
 func (b *BeaconState) CanBuilderCoverBid(builderIndex primitives.BuilderIndex, bidAmount primitives.Gwei) (bool, error) {
 	if b.version < version.Gloas {
 		return false, errNotSupported("CanBuilderCoverBid", b.version)
@@ -156,3 +152,138 @@ func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment,
 
 	return b.builderPendingPaymentsVal(), nil
 }
+
+// LatestExecutionPayloadBid returns the cached latest execution payload bid for Gloas.
+func (b *BeaconState) LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	if b.latestExecutionPayloadBid == nil {
+		return nil, nil
+	}
+
+	return blocks.WrappedROExecutionPayloadBid(b.latestExecutionPayloadBid.Copy())
+}
+
+// WithdrawalsMatchPayloadExpected returns true if the given withdrawals root matches the state's
+// payload_expected_withdrawals root.
+func (b *BeaconState) WithdrawalsMatchPayloadExpected(withdrawals []*enginev1.Withdrawal) (bool, error) {
+	if b.version < version.Gloas {
+		return false, errNotSupported("WithdrawalsMatchPayloadExpected", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	cfg := params.BeaconConfig()
+
+	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, cfg.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return false, fmt.Errorf("could not compute withdrawals root: %w", err)
+	}
+
+	expected := b.payloadExpectedWithdrawals
+	if expected == nil {
+		expected = []*enginev1.Withdrawal{}
+	}
+	expectedRoot, err := ssz.WithdrawalSliceRoot(expected, cfg.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return false, fmt.Errorf("could not compute expected withdrawals root: %w", err)
+	}
+
+	return withdrawalsRoot == expectedRoot, nil
+}
+
+// Builder returns the builder at the given index.
+func (b *BeaconState) Builder(index primitives.BuilderIndex) (*ethpb.Builder, error) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	if b.builders == nil {
+		return nil, nil
+	}
+	if uint64(index) >= uint64(len(b.builders)) {
+		return nil, fmt.Errorf("builder index %d out of bounds", index)
+	}
+	if b.builders[index] == nil {
+		return nil, nil
+	}
+
+	return ethpb.CopyBuilder(b.builders[index]), nil
+}
+
+// BuilderIndexByPubkey returns the builder index for the given pubkey, if present.
+func (b *BeaconState) BuilderIndexByPubkey(pubkey [fieldparams.BLSPubkeyLength]byte) (primitives.BuilderIndex, bool) {
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	for i, builder := range b.builders {
+		if builder == nil {
+			continue
+		}
+		if bytes.Equal(builder.Pubkey, pubkey[:]) {
+			return primitives.BuilderIndex(i), true
+		}
+	}
+	return 0, false
+}
+
+// BuilderPendingWithdrawals returns a copy of the builder pending withdrawals.
+func (b *BeaconState) BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("BuilderPendingWithdrawals", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.builderPendingWithdrawalsVal(), nil
+}
+
+// Builders returns a copy of the builders registry.
+func (b *BeaconState) Builders() ([]*ethpb.Builder, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("Builders", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.buildersVal(), nil
+}
+
+// NextWithdrawalBuilderIndex returns the next withdrawal builder index.
+func (b *BeaconState) NextWithdrawalBuilderIndex() (primitives.BuilderIndex, error) {
+	if b.version < version.Gloas {
+		return 0, errNotSupported("NextWithdrawalBuilderIndex", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.nextWithdrawalBuilderIndex, nil
+}
+
+// ExecutionPayloadAvailability returns a copy of the execution payload availability.
+func (b *BeaconState) ExecutionPayloadAvailability() ([]byte, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("ExecutionPayloadAvailability", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.executionPayloadAvailabilityVal(), nil
+}
+
+// PayloadExpectedWithdrawals returns a copy of the payload expected withdrawals.
+func (b *BeaconState) PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
+	if b.version < version.Gloas {
+		return nil, errNotSupported("PayloadExpectedWithdrawals", b.version)
+	}
+
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.payloadExpectedWithdrawalsVal(), nil
+}

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

@@ -5,8 +5,10 @@ import (
 	"testing"
 
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
@@ -166,3 +168,279 @@ func TestBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
 	_, err = st.BuilderPendingPayments()
 	require.ErrorContains(t, "BuilderPendingPayments", err)
 }
+
+func TestBuilderPendingWithdrawals(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.BuilderPendingWithdrawals()
+		require.ErrorContains(t, "BuilderPendingWithdrawals", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		original := []*ethpb.BuilderPendingWithdrawal{
+			{Amount: 10, BuilderIndex: 1},
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			BuilderPendingWithdrawals: original,
+		})
+		require.NoError(t, err)
+
+		got1, err := st.BuilderPendingWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, original, got1)
+
+		got1[0].Amount = 99
+		got2, err := st.BuilderPendingWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, original, got2)
+	})
+}
+
+func TestBuildersGetter(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.Builders()
+		require.ErrorContains(t, "Builders", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		pubkey := bytes.Repeat([]byte{0xAB}, fieldparams.BLSPubkeyLength)
+		buildr := &ethpb.Builder{
+			Pubkey:            pubkey,
+			Balance:           42,
+			DepositEpoch:      3,
+			WithdrawableEpoch: 4,
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{buildr},
+		})
+		require.NoError(t, err)
+
+		got1, err := st.Builders()
+		require.NoError(t, err)
+		require.DeepEqual(t, buildr, got1[0])
+
+		got1[0].Pubkey[0] = 0xFF
+		got2, err := st.Builders()
+		require.NoError(t, err)
+		require.DeepEqual(t, buildr, got2[0])
+	})
+}
+
+func TestNextWithdrawalBuilderIndex(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.NextWithdrawalBuilderIndex()
+		require.ErrorContains(t, "NextWithdrawalBuilderIndex", err)
+	})
+
+	t.Run("returns configured value", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			NextWithdrawalBuilderIndex: 2,
+		})
+		require.NoError(t, err)
+
+		got, err := st.NextWithdrawalBuilderIndex()
+		require.NoError(t, err)
+		require.Equal(t, primitives.BuilderIndex(2), got)
+	})
+}
+
+func TestExecutionPayloadAvailability(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.ExecutionPayloadAvailability()
+		require.ErrorContains(t, "ExecutionPayloadAvailability", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		availability := []byte{0x01, 0x00, 0x01}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			ExecutionPayloadAvailability: availability,
+		})
+		require.NoError(t, err)
+
+		got1, err := st.ExecutionPayloadAvailability()
+		require.NoError(t, err)
+		require.DeepEqual(t, availability, got1)
+
+		got1[0] = 0xFF
+		got2, err := st.ExecutionPayloadAvailability()
+		require.NoError(t, err)
+		require.DeepEqual(t, availability, got2)
+	})
+}
+
+func TestPayloadExpectedWithdrawals(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+		st := stIface.(*state_native.BeaconState)
+
+		_, err = st.PayloadExpectedWithdrawals()
+		require.ErrorContains(t, "PayloadExpectedWithdrawals", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		original := enginev1.Withdrawal{
+			Index:          1,
+			ValidatorIndex: 2,
+			Address:        bytes.Repeat([]byte{0x01}, 20),
+			Amount:         10,
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			PayloadExpectedWithdrawals: []*enginev1.Withdrawal{&original},
+		})
+		require.NoError(t, err)
+
+		got1, err := st.PayloadExpectedWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, &original, got1[0])
+
+		got1[0].Amount = 99
+		got2, err := st.PayloadExpectedWithdrawals()
+		require.NoError(t, err)
+		require.DeepEqual(t, &original, got2[0])
+	})
+}
+
+func TestWithdrawalsMatchPayloadExpected(t *testing.T) {
+	t.Run("returns error before gloas", func(t *testing.T) {
+		stIface, _ := util.DeterministicGenesisState(t, 1)
+		native, ok := stIface.(*state_native.BeaconState)
+		require.Equal(t, true, ok)
+
+		_, err := native.WithdrawalsMatchPayloadExpected(nil)
+		require.ErrorContains(t, "is not supported", err)
+	})
+
+	t.Run("returns true when roots match", func(t *testing.T) {
+		withdrawals := []*enginev1.Withdrawal{
+			{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 10},
+		}
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			PayloadExpectedWithdrawals: withdrawals,
+		})
+		require.NoError(t, err)
+
+		ok, err := st.WithdrawalsMatchPayloadExpected(withdrawals)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+
+	t.Run("returns false when roots do not match", func(t *testing.T) {
+		expected := []*enginev1.Withdrawal{
+			{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 10},
+		}
+		actual := []*enginev1.Withdrawal{
+			{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 11},
+		}
+
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			PayloadExpectedWithdrawals: expected,
+		})
+		require.NoError(t, err)
+
+		ok, err := st.WithdrawalsMatchPayloadExpected(actual)
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+}
+
+func TestBuilder(t *testing.T) {
+	t.Run("nil builders returns nil", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: nil,
+		})
+		require.NoError(t, err)
+
+		got, err := st.Builder(0)
+		require.NoError(t, err)
+		require.Equal(t, (*ethpb.Builder)(nil), got)
+	})
+
+	t.Run("out of bounds returns error", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{{}},
+		})
+		require.NoError(t, err)
+
+		_, err = st.Builder(1)
+		require.ErrorContains(t, "out of bounds", err)
+	})
+
+	t.Run("returns copy", func(t *testing.T) {
+		pubkey := bytes.Repeat([]byte{0xAA}, fieldparams.BLSPubkeyLength)
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{
+				{
+					Pubkey:            pubkey,
+					Balance:           42,
+					DepositEpoch:      3,
+					WithdrawableEpoch: 4,
+				},
+			},
+		})
+		require.NoError(t, err)
+
+		got1, err := st.Builder(0)
+		require.NoError(t, err)
+		require.NotEqual(t, (*ethpb.Builder)(nil), got1)
+		require.Equal(t, primitives.Gwei(42), got1.Balance)
+		require.DeepEqual(t, pubkey, got1.Pubkey)
+
+		// Mutate returned builder; state should be unchanged.
+		got1.Pubkey[0] = 0xFF
+		got2, err := st.Builder(0)
+		require.NoError(t, err)
+		require.Equal(t, byte(0xAA), got2.Pubkey[0])
+	})
+}
+
+func TestBuilderIndexByPubkey(t *testing.T) {
+	t.Run("not found returns false", func(t *testing.T) {
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{
+				{Pubkey: bytes.Repeat([]byte{0x11}, fieldparams.BLSPubkeyLength)},
+			},
+		})
+		require.NoError(t, err)
+
+		var pk [fieldparams.BLSPubkeyLength]byte
+		copy(pk[:], bytes.Repeat([]byte{0x22}, fieldparams.BLSPubkeyLength))
+		idx, ok := st.BuilderIndexByPubkey(pk)
+		require.Equal(t, false, ok)
+		require.Equal(t, primitives.BuilderIndex(0), idx)
+	})
+
+	t.Run("skips nil entries and finds match", func(t *testing.T) {
+		wantIdx := primitives.BuilderIndex(1)
+		wantPkBytes := bytes.Repeat([]byte{0xAB}, fieldparams.BLSPubkeyLength)
+
+		st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Builders: []*ethpb.Builder{
+				nil,
+				{Pubkey: wantPkBytes},
+			},
+		})
+		require.NoError(t, err)
+
+		var pk [fieldparams.BLSPubkeyLength]byte
+		copy(pk[:], wantPkBytes)
+		idx, ok := st.BuilderIndexByPubkey(pk)
+		require.Equal(t, true, ok)
+		require.Equal(t, wantIdx, idx)
+	})
+}

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

@@ -5,11 +5,14 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
 )
 
 // RotateBuilderPendingPayments rotates the queue by dropping slots per epoch payments from the
@@ -82,20 +85,20 @@ func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid)
 	parentBlockRoot := h.ParentBlockRoot()
 	blockHash := h.BlockHash()
 	randao := h.PrevRandao()
-	blobKzgCommitments := h.BlobKzgCommitments()
+	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
 	feeRecipient := h.FeeRecipient()
 	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    parentBlockHash[:],
-		ParentBlockRoot:    parentBlockRoot[:],
-		BlockHash:          blockHash[:],
-		PrevRandao:         randao[:],
-		GasLimit:           h.GasLimit(),
-		BuilderIndex:       h.BuilderIndex(),
-		Slot:               h.Slot(),
-		Value:              h.Value(),
-		ExecutionPayment:   h.ExecutionPayment(),
-		BlobKzgCommitments: blobKzgCommitments,
-		FeeRecipient:       feeRecipient[:],
+		ParentBlockHash:        parentBlockHash[:],
+		ParentBlockRoot:        parentBlockRoot[:],
+		BlockHash:              blockHash[:],
+		PrevRandao:             randao[:],
+		GasLimit:               h.GasLimit(),
+		BuilderIndex:           h.BuilderIndex(),
+		Slot:                   h.Slot(),
+		Value:                  h.Value(),
+		ExecutionPayment:       h.ExecutionPayment(),
+		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
+		FeeRecipient:           feeRecipient[:],
 	}
 	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
 
@@ -121,6 +124,41 @@ func (b *BeaconState) ClearBuilderPendingPayment(index primitives.Slot) error {
 	return nil
 }
 
+// QueueBuilderPayment implements the builder payment queuing logic for Gloas.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
+// amount = payment.withdrawal.amount
+// if amount > 0:
+//
+//	state.builder_pending_withdrawals.append(payment.withdrawal)
+//
+// state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = BuilderPendingPayment()
+func (b *BeaconState) QueueBuilderPayment() error {
+	if b.version < version.Gloas {
+		return errNotSupported("QueueBuilderPayment", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	slot := b.slot
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
+	if uint64(paymentIndex) >= uint64(len(b.builderPendingPayments)) {
+		return fmt.Errorf("builder pending payments index %d out of range (len=%d)", paymentIndex, len(b.builderPendingPayments))
+	}
+
+	payment := b.builderPendingPayments[paymentIndex]
+	if payment != nil && payment.Withdrawal != nil && payment.Withdrawal.Amount > 0 {
+		b.builderPendingWithdrawals = append(b.builderPendingWithdrawals, ethpb.CopyBuilderPendingWithdrawal(payment.Withdrawal))
+		b.markFieldAsDirty(types.BuilderPendingWithdrawals)
+	}
+
+	b.builderPendingPayments[paymentIndex] = emptyBuilderPendingPayment
+	b.markFieldAsDirty(types.BuilderPendingPayments)
+	return nil
+}
+
 // SetBuilderPendingPayment sets a builder pending payment at the specified index.
 func (b *BeaconState) SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error {
 	if b.version < version.Gloas {
@@ -161,3 +199,91 @@ func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val
 	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
 	return nil
 }
+
+// SetLatestBlockHash sets the latest execution block hash.
+func (b *BeaconState) SetLatestBlockHash(hash [32]byte) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.latestBlockHash = hash[:]
+	b.markFieldAsDirty(types.LatestBlockHash)
+	return nil
+}
+
+// SetExecutionPayloadAvailability sets the execution payload availability bit for a specific slot.
+func (b *BeaconState) SetExecutionPayloadAvailability(index primitives.Slot, available bool) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	bitIndex := index % params.BeaconConfig().SlotsPerHistoricalRoot
+	byteIndex := bitIndex / 8
+	bitPosition := bitIndex % 8
+
+	// Set or clear the bit
+	if available {
+		b.executionPayloadAvailability[byteIndex] |= 1 << bitPosition
+	} else {
+		b.executionPayloadAvailability[byteIndex] &^= 1 << bitPosition
+	}
+
+	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
+	return nil
+}
+
+// IncreaseBuilderBalance increases the balance of the builder at the given index.
+func (b *BeaconState) IncreaseBuilderBalance(index primitives.BuilderIndex, amount uint64) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	if b.builders == nil || uint64(index) >= uint64(len(b.builders)) {
+		return fmt.Errorf("builder index %d out of bounds", index)
+	}
+	if b.builders[index] == nil {
+		return fmt.Errorf("builder at index %d is nil", index)
+	}
+
+	builder := ethpb.CopyBuilder(b.builders[index])
+	builder.Balance += primitives.Gwei(amount)
+	b.builders[index] = builder
+
+	b.markFieldAsDirty(types.Builders)
+	return nil
+}
+
+// AddBuilderFromDeposit creates or replaces a builder entry derived from a deposit.
+func (b *BeaconState) AddBuilderFromDeposit(pubkey [fieldparams.BLSPubkeyLength]byte, withdrawalCredentials [fieldparams.RootLength]byte, amount uint64) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	currentEpoch := slots.ToEpoch(b.slot)
+	index := b.builderInsertionIndex(currentEpoch)
+
+	builder := &ethpb.Builder{
+		Pubkey:            bytesutil.SafeCopyBytes(pubkey[:]),
+		Version:           []byte{withdrawalCredentials[0]},
+		ExecutionAddress:  bytesutil.SafeCopyBytes(withdrawalCredentials[12:]),
+		Balance:           primitives.Gwei(amount),
+		DepositEpoch:      currentEpoch,
+		WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+	}
+
+	if index < primitives.BuilderIndex(len(b.builders)) {
+		b.builders[index] = builder
+	} else {
+		gap := index - primitives.BuilderIndex(len(b.builders)) + 1
+		b.builders = append(b.builders, make([]*ethpb.Builder, gap)...)
+		b.builders[index] = builder
+	}
+
+	b.markFieldAsDirty(types.Builders)
+	return nil
+}
+
+func (b *BeaconState) builderInsertionIndex(currentEpoch primitives.Epoch) primitives.BuilderIndex {
+	for i, builder := range b.builders {
+		if builder.WithdrawableEpoch <= currentEpoch && builder.Balance == 0 {
+			return primitives.BuilderIndex(i)
+		}
+	}
+	return primitives.BuilderIndex(len(b.builders))
+}

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

@@ -14,17 +14,17 @@ import (
 )
 
 type testExecutionPayloadBid struct {
-	parentBlockHash    [32]byte
-	parentBlockRoot    [32]byte
-	blockHash          [32]byte
-	prevRandao         [32]byte
-	blobKzgCommitments [][]byte
-	feeRecipient       [20]byte
-	gasLimit           uint64
-	builderIndex       primitives.BuilderIndex
-	slot               primitives.Slot
-	value              primitives.Gwei
-	executionPayment   primitives.Gwei
+	parentBlockHash        [32]byte
+	parentBlockRoot        [32]byte
+	blockHash              [32]byte
+	prevRandao             [32]byte
+	blobKzgCommitmentsRoot [32]byte
+	feeRecipient           [20]byte
+	gasLimit               uint64
+	builderIndex           primitives.BuilderIndex
+	slot                   primitives.Slot
+	value                  primitives.Gwei
+	executionPayment       primitives.Gwei
 }
 
 func (t testExecutionPayloadBid) ParentBlockHash() [32]byte { return t.parentBlockHash }
@@ -40,12 +40,9 @@ func (t testExecutionPayloadBid) Value() primitives.Gwei { return t.value }
 func (t testExecutionPayloadBid) ExecutionPayment() primitives.Gwei {
 	return t.executionPayment
 }
-func (t testExecutionPayloadBid) BlobKzgCommitments() [][]byte { return t.blobKzgCommitments }
-func (t testExecutionPayloadBid) BlobKzgCommitmentCount() uint64 {
-	return uint64(len(t.blobKzgCommitments))
-}
-func (t testExecutionPayloadBid) FeeRecipient() [20]byte { return t.feeRecipient }
-func (t testExecutionPayloadBid) IsNil() bool            { return false }
+func (t testExecutionPayloadBid) BlobKzgCommitmentsRoot() [32]byte { return t.blobKzgCommitmentsRoot }
+func (t testExecutionPayloadBid) FeeRecipient() [20]byte           { return t.feeRecipient }
+func (t testExecutionPayloadBid) IsNil() bool                      { return false }
 
 func TestSetExecutionPayloadBid(t *testing.T) {
 	t.Run("previous fork returns expected error", func(t *testing.T) {
@@ -60,7 +57,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			parentBlockRoot = [32]byte(bytes.Repeat([]byte{0xCD}, 32))
 			blockHash       = [32]byte(bytes.Repeat([]byte{0xEF}, 32))
 			prevRandao      = [32]byte(bytes.Repeat([]byte{0x11}, 32))
-			blobCommitments = [][]byte{bytes.Repeat([]byte{0x22}, 48)}
+			blobRoot        = [32]byte(bytes.Repeat([]byte{0x22}, 32))
 			feeRecipient    [20]byte
 		)
 		copy(feeRecipient[:], bytes.Repeat([]byte{0x33}, len(feeRecipient)))
@@ -69,17 +66,17 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			dirtyFields: make(map[types.FieldIndex]bool),
 		}
 		bid := testExecutionPayloadBid{
-			parentBlockHash:    parentBlockHash,
-			parentBlockRoot:    parentBlockRoot,
-			blockHash:          blockHash,
-			prevRandao:         prevRandao,
-			blobKzgCommitments: blobCommitments,
-			feeRecipient:       feeRecipient,
-			gasLimit:           123,
-			builderIndex:       7,
-			slot:               9,
-			value:              11,
-			executionPayment:   22,
+			parentBlockHash:        parentBlockHash,
+			parentBlockRoot:        parentBlockRoot,
+			blockHash:              blockHash,
+			prevRandao:             prevRandao,
+			blobKzgCommitmentsRoot: blobRoot,
+			feeRecipient:           feeRecipient,
+			gasLimit:               123,
+			builderIndex:           7,
+			slot:                   9,
+			value:                  11,
+			executionPayment:       22,
 		}
 
 		require.NoError(t, st.SetExecutionPayloadBid(bid))
@@ -89,7 +86,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 		require.DeepEqual(t, parentBlockRoot[:], st.latestExecutionPayloadBid.ParentBlockRoot)
 		require.DeepEqual(t, blockHash[:], st.latestExecutionPayloadBid.BlockHash)
 		require.DeepEqual(t, prevRandao[:], st.latestExecutionPayloadBid.PrevRandao)
-		require.DeepEqual(t, blobCommitments, st.latestExecutionPayloadBid.BlobKzgCommitments)
+		require.DeepEqual(t, blobRoot[:], st.latestExecutionPayloadBid.BlobKzgCommitmentsRoot)
 		require.DeepEqual(t, feeRecipient[:], st.latestExecutionPayloadBid.FeeRecipient)
 		require.Equal(t, uint64(123), st.latestExecutionPayloadBid.GasLimit)
 		require.Equal(t, primitives.BuilderIndex(7), st.latestExecutionPayloadBid.BuilderIndex)
@@ -184,6 +181,80 @@ func TestClearBuilderPendingPayment(t *testing.T) {
 	})
 }
 
+func TestQueueBuilderPayment(t *testing.T) {
+	t.Run("previous fork returns expected error", func(t *testing.T) {
+		st := &BeaconState{version: version.Fulu}
+		err := st.QueueBuilderPayment()
+		require.ErrorContains(t, "is not supported", err)
+	})
+
+	t.Run("appends withdrawal, clears payment, and marks dirty", func(t *testing.T) {
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+		slot := primitives.Slot(3)
+		paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
+
+		st := &BeaconState{
+			version:                   version.Gloas,
+			slot:                      slot,
+			dirtyFields:               make(map[types.FieldIndex]bool),
+			rebuildTrie:               make(map[types.FieldIndex]bool),
+			sharedFieldReferences:     make(map[types.FieldIndex]*stateutil.Reference),
+			builderPendingPayments:    make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2),
+			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
+		}
+		st.builderPendingPayments[paymentIndex] = &ethpb.BuilderPendingPayment{
+			Weight: 1,
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: bytes.Repeat([]byte{0xAB}, 20),
+				Amount:       99,
+				BuilderIndex: 1,
+			},
+		}
+
+		require.NoError(t, st.QueueBuilderPayment())
+		require.Equal(t, emptyBuilderPendingPayment, st.builderPendingPayments[paymentIndex])
+		require.Equal(t, true, st.dirtyFields[types.BuilderPendingPayments])
+		require.Equal(t, true, st.dirtyFields[types.BuilderPendingWithdrawals])
+		require.Equal(t, 1, len(st.builderPendingWithdrawals))
+		require.DeepEqual(t, bytes.Repeat([]byte{0xAB}, 20), st.builderPendingWithdrawals[0].FeeRecipient)
+		require.Equal(t, primitives.Gwei(99), st.builderPendingWithdrawals[0].Amount)
+
+		// Ensure copied withdrawal is not aliased.
+		st.builderPendingPayments[paymentIndex].Withdrawal.FeeRecipient[0] = 0x01
+		require.Equal(t, byte(0xAB), st.builderPendingWithdrawals[0].FeeRecipient[0])
+	})
+
+	t.Run("zero amount does not append withdrawal", func(t *testing.T) {
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+		slot := primitives.Slot(3)
+		paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
+
+		st := &BeaconState{
+			version:                   version.Gloas,
+			slot:                      slot,
+			dirtyFields:               make(map[types.FieldIndex]bool),
+			rebuildTrie:               make(map[types.FieldIndex]bool),
+			sharedFieldReferences:     make(map[types.FieldIndex]*stateutil.Reference),
+			builderPendingPayments:    make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2),
+			builderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
+		}
+		st.builderPendingPayments[paymentIndex] = &ethpb.BuilderPendingPayment{
+			Weight: 1,
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: bytes.Repeat([]byte{0xAB}, 20),
+				Amount:       0,
+				BuilderIndex: 1,
+			},
+		}
+
+		require.NoError(t, st.QueueBuilderPayment())
+		require.Equal(t, emptyBuilderPendingPayment, st.builderPendingPayments[paymentIndex])
+		require.Equal(t, true, st.dirtyFields[types.BuilderPendingPayments])
+		require.Equal(t, false, st.dirtyFields[types.BuilderPendingWithdrawals])
+		require.Equal(t, 0, len(st.builderPendingWithdrawals))
+	})
+}
+
 func TestRotateBuilderPendingPayments(t *testing.T) {
 	totalPayments := 2 * params.BeaconConfig().SlotsPerEpoch
 	payments := make([]*ethpb.BuilderPendingPayment, totalPayments)
@@ -331,3 +402,134 @@ func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconSta
 
 	return st.(*BeaconState)
 }
+
+func TestSetLatestBlockHash(t *testing.T) {
+	var hash [32]byte
+	copy(hash[:], []byte("latest-block-hash"))
+
+	state := &BeaconState{
+		dirtyFields: make(map[types.FieldIndex]bool),
+	}
+
+	require.NoError(t, state.SetLatestBlockHash(hash))
+	require.Equal(t, true, state.dirtyFields[types.LatestBlockHash])
+	require.DeepEqual(t, hash[:], state.latestBlockHash)
+}
+
+func TestSetExecutionPayloadAvailability(t *testing.T) {
+	state := &BeaconState{
+		executionPayloadAvailability: make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8),
+		dirtyFields:                  make(map[types.FieldIndex]bool),
+	}
+
+	slot := primitives.Slot(10)
+	bitIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
+	byteIndex := bitIndex / 8
+	bitPosition := bitIndex % 8
+
+	require.NoError(t, state.SetExecutionPayloadAvailability(slot, true))
+	require.Equal(t, true, state.dirtyFields[types.ExecutionPayloadAvailability])
+	require.Equal(t, byte(1<<bitPosition), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
+
+	require.NoError(t, state.SetExecutionPayloadAvailability(slot, false))
+	require.Equal(t, byte(0), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
+}
+
+func TestIncreaseBuilderBalance(t *testing.T) {
+	t.Run("out of bounds returns error", func(t *testing.T) {
+		st := &BeaconState{
+			version:     version.Gloas,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders:    []*ethpb.Builder{},
+		}
+
+		err := st.IncreaseBuilderBalance(0, 1)
+		require.ErrorContains(t, "out of bounds", err)
+		require.Equal(t, false, st.dirtyFields[types.Builders])
+	})
+
+	t.Run("nil builder returns error", func(t *testing.T) {
+		st := &BeaconState{
+			version:     version.Gloas,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders:    []*ethpb.Builder{nil},
+		}
+
+		err := st.IncreaseBuilderBalance(0, 1)
+		require.ErrorContains(t, "is nil", err)
+		require.Equal(t, false, st.dirtyFields[types.Builders])
+	})
+
+	t.Run("increments and marks dirty", func(t *testing.T) {
+		orig := &ethpb.Builder{Balance: 10}
+		st := &BeaconState{
+			version:     version.Gloas,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders:    []*ethpb.Builder{orig},
+		}
+
+		require.NoError(t, st.IncreaseBuilderBalance(0, 5))
+		require.Equal(t, primitives.Gwei(15), st.builders[0].Balance)
+		require.Equal(t, true, st.dirtyFields[types.Builders])
+		// Copy-on-write semantics: builder pointer replaced.
+		require.NotEqual(t, orig, st.builders[0])
+	})
+}
+
+func TestAddBuilderFromDeposit(t *testing.T) {
+	t.Run("reuses empty withdrawable slot", func(t *testing.T) {
+		var pubkey [48]byte
+		copy(pubkey[:], bytes.Repeat([]byte{0xAA}, 48))
+		var wc [32]byte
+		copy(wc[:], bytes.Repeat([]byte{0xBB}, 32))
+		wc[0] = 0x42 // version byte
+
+		st := &BeaconState{
+			version:     version.Gloas,
+			slot:        0, // epoch 0
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders: []*ethpb.Builder{
+				{
+					WithdrawableEpoch: 0,
+					Balance:           0,
+				},
+			},
+		}
+
+		require.NoError(t, st.AddBuilderFromDeposit(pubkey, wc, 123))
+		require.Equal(t, 1, len(st.builders))
+		got := st.builders[0]
+		require.NotNil(t, got)
+		require.DeepEqual(t, pubkey[:], got.Pubkey)
+		require.DeepEqual(t, []byte{0x42}, got.Version)
+		require.DeepEqual(t, wc[12:], got.ExecutionAddress)
+		require.Equal(t, primitives.Gwei(123), got.Balance)
+		require.Equal(t, primitives.Epoch(0), got.DepositEpoch)
+		require.Equal(t, params.BeaconConfig().FarFutureEpoch, got.WithdrawableEpoch)
+		require.Equal(t, true, st.dirtyFields[types.Builders])
+	})
+
+	t.Run("appends new builder when no reusable slot", func(t *testing.T) {
+		var pubkey [48]byte
+		copy(pubkey[:], bytes.Repeat([]byte{0xAA}, 48))
+		var wc [32]byte
+		copy(wc[:], bytes.Repeat([]byte{0xBB}, 32))
+
+		st := &BeaconState{
+			version:     version.Gloas,
+			slot:        0,
+			dirtyFields: make(map[types.FieldIndex]bool),
+			builders: []*ethpb.Builder{
+				{
+					WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+					Balance:           1,
+				},
+			},
+		}
+
+		require.NoError(t, st.AddBuilderFromDeposit(pubkey, wc, 5))
+		require.Equal(t, 2, len(st.builders))
+		require.NotNil(t, st.builders[1])
+		require.Equal(t, primitives.Gwei(5), st.builders[1].Balance)
+	})
+}

beacon-chain/verification/data_column_test.go

@@ -1027,10 +1027,10 @@ func TestGetVerifyingStateEdgeCases(t *testing.T) {
 				sc: signatureCache,
 				sr: &mockStateByRooter{sbr: sbrErrorIfCalled(t)}, // Should not be called
 				hsp: &mockHeadStateProvider{
-					headRoot:          parentRoot[:],    // Same as parent
-					headSlot:          32,               // Epoch 1
-					headState:         fuluState.Copy(), // HeadState (not ReadOnly) for ProcessSlots
-					headStateReadOnly: nil,              // Should not use ReadOnly path
+					headRoot: parentRoot[:],     // Same as parent
+					headSlot: 32,                // Epoch 1
+					headState: fuluState.Copy(), // HeadState (not ReadOnly) for ProcessSlots
+					headStateReadOnly: nil,      // Should not use ReadOnly path
 				},
 				fc: &mockForkchoicer{
 					// Return same root for both to simulate same chain
@@ -1045,8 +1045,8 @@ func TestGetVerifyingStateEdgeCases(t *testing.T) {
 		// Wrap to detect HeadState call
 		originalHsp := initializer.shared.hsp.(*mockHeadStateProvider)
 		wrappedHsp := &mockHeadStateProvider{
-			headRoot:  originalHsp.headRoot,
-			headSlot:  originalHsp.headSlot,
+			headRoot: originalHsp.headRoot,
+			headSlot: originalHsp.headSlot,
 			headState: originalHsp.headState,
 		}
 		initializer.shared.hsp = &headStateCallTracker{

changelog/aarshkshah1992_set-beacon-node-options.md

@@ -1,3 +0,0 @@
-### Added
-
-- Set beacon node options after reading the config file.

changelog/bastin_fix-genlogs-gitignore-bug.md

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

changelog/bastin_fix-logging-issue.md

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

changelog/farazdagi_fix-hashtree-darwin-amd64.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fix Bazel build failure on macOS x86_64 (darwin_amd64) (adds missing assembly stub to hashtree patch).

changelog/fernantho_connect-merkle-proofs-with-endpoint.md

@@ -1,6 +0,0 @@
-### Added
-
-- Added new proofCollector type to ssz-query
-
-### Ignored
-- Added testing covering the production of Merkle proof from Phase0 beacon state and benchmarked against real Hoodi beacon state (Fulu version)

changelog/james-prysm_grpc-fallback.md

@@ -1,7 +0,0 @@
-### Changed
-
-- gRPC fallback now matches rest api implementation and will also check and connect to only synced nodes.
-
-### Removed
-
-- gRPC resolver for load balancing, the new implementation matches rest api's so we should remove the resolver so it's handled the same way for consistency.

changelog/james-prysm_host-fallback-cleanup.md

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

changelog/james-prysm_update-health-endpoint.md

@@ -1,3 +0,0 @@
-### Changed
-
-- gRPC health endpoint will now return an error on syncing or optimistic status showing that it's unavailable.

changelog/jtraglia-add-specrefs-readme.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added README for maintaining specrefs.

changelog/jtraglia-improve-ethspecify-integration.md

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

changelog/jtraglia-nightly-reftests-with-run-id.md

@@ -1,3 +0,0 @@
-### Added
-
-- The ability to download the nightly reference tests from a specific day.

changelog/potuz_forkchoice_unused_highestblockdelay.md

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

changelog/potuz_forkchoice_unused_last_root.md

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

changelog/potuz_remove_unused_map.md

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

changelog/pvl-bbolt-read-copy.md

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

changelog/pvl-golangci-tests.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Updated golangci to run lint on tests too.

changelog/satushh-close-host.md

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

changelog/syjn99_docs-ssz-ql.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Add handy documentation for SSZ Query package (`encoding/ssz/query`).

changelog/terencechain_add-process-execution-payload-gloas.md

@@ -0,0 +1,2 @@
+### Added
+- Add process execution payload for gloas

changelog/terencechain_gloas-ptc-sampling.md

@@ -1,2 +0,0 @@
-### Changed
-- Sample PTC per committee to reduce allocations.

changelog/tt_move-kzg-commitments.md

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

changelog/tt_run-gofmt.md

@@ -1,2 +0,0 @@
-### Ignored
-- Run go fmt

cmd/beacon-chain/execution/log.go

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

cmd/beacon-chain/main.go

@@ -188,8 +188,8 @@ func before(ctx *cli.Context) error {
 		return errors.Wrap(err, "failed to parse log vmodule")
 	}
 
-	// set the global logging level and data
-	logs.SetLoggingLevelAndData(verbosityLevel, vmodule, maxLevel, ctx.Bool(flags.DisableEphemeralLogFile.Name))
+	// set the global logging level to allow for the highest verbosity requested
+	logs.SetLoggingLevel(max(verbosityLevel, maxLevel))
 
 	format := ctx.String(cmd.LogFormat.Name)
 	switch format {
@@ -210,7 +210,6 @@ func before(ctx *cli.Context) error {
 			Formatter:     formatter,
 			Writer:        os.Stderr,
 			AllowedLevels: logrus.AllLevels[:max(verbosityLevel, maxLevel)+1],
-			Identifier:    logs.LogTargetUser,
 		})
 	case "fluentd":
 		f := joonix.NewFormatter()
@@ -368,8 +367,17 @@ func startNode(ctx *cli.Context, cancel context.CancelFunc) error {
 		backfill.BeaconNodeOptions,
 		das.BeaconNodeOptions,
 	}
+	for _, of := range optFuncs {
+		ofo, err := of(ctx)
+		if err != nil {
+			return err
+		}
+		if ofo != nil {
+			opts = append(opts, ofo...)
+		}
+	}
 
-	beacon, err := node.New(ctx, cancel, optFuncs, opts...)
+	beacon, err := node.New(ctx, cancel, opts...)
 	if err != nil {
 		return fmt.Errorf("unable to start beacon node: %w", err)
 	}

cmd/validator/main.go

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

config/params/configset_test.go

@@ -98,6 +98,7 @@ func compareConfigs(t *testing.T, expected, actual *BeaconChainConfig) {
 	require.DeepEqual(t, expected.EjectionBalance, actual.EjectionBalance)
 	require.DeepEqual(t, expected.EffectiveBalanceIncrement, actual.EffectiveBalanceIncrement)
 	require.DeepEqual(t, expected.BLSWithdrawalPrefixByte, actual.BLSWithdrawalPrefixByte)
+	require.DeepEqual(t, expected.BuilderWithdrawalPrefixByte, actual.BuilderWithdrawalPrefixByte)
 	require.DeepEqual(t, expected.ZeroHash, actual.ZeroHash)
 	require.DeepEqual(t, expected.GenesisDelay, actual.GenesisDelay)
 	require.DeepEqual(t, expected.MinAttestationInclusionDelay, actual.MinAttestationInclusionDelay)

config/params/loader_test.go

@@ -119,6 +119,7 @@ func assertEqualConfigs(t *testing.T, name string, fields []string, expected, ac
 	// Initial values.
 	assert.DeepEqual(t, expected.GenesisForkVersion, actual.GenesisForkVersion, "%s: GenesisForkVersion", name)
 	assert.DeepEqual(t, expected.BLSWithdrawalPrefixByte, actual.BLSWithdrawalPrefixByte, "%s: BLSWithdrawalPrefixByte", name)
+	assert.DeepEqual(t, expected.BuilderWithdrawalPrefixByte, actual.BuilderWithdrawalPrefixByte, "%s: BuilderWithdrawalPrefixByte", name)
 	assert.DeepEqual(t, expected.ETH1AddressWithdrawalPrefixByte, actual.ETH1AddressWithdrawalPrefixByte, "%s: ETH1AddressWithdrawalPrefixByte", name)
 
 	// Time parameters.