gaz

**What type of PR is this?**


Bug fix

**What does this PR do? Why is it needed?**
  
It appears that #16216 introduced hashtree integration but broke builds
on macOS Intel (darwin_amd64).

```                                                                                                                                                                                                                                                                          
  Error:                                                                                                                                                                                                                                                                  
  Undefined symbols for architecture x86_64:                                                                                                                                                                                                                              
    "_github.com/OffchainLabs/hashtree.HashtreeHash"                                                                                                                                                                                                                      
```

The Bazel patch for hashtree was missing `wrapper_darwin_amd64.s`. So,
`//go:noescape` in `bindings.go` assumes that symbols are available
elsewhere, and while on other platforms optimized version is used, on
Darwin we have stub (symbol still must be available), which needs to be
referenced -- hence, this PR.

**Other notes for review**

I've re-checked using `bazel clean && bazel build //cmd/beacon-chain` --
it was failing before, works now.

cc @potuz as original patch author

**Acknowledgements**

- [x] I have read
[CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
- [x] I have included a uniquely named [changelog fragment
file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd).
- [x] I have added a description with sufficient context for reviewers
to understand this PR.
- [x] I have tested that my changes work as expected and I added a
testing plan to the PR description (if applicable).

Co-authored-by: Potuz <potuz@prysmaticlabs.com>

beacon-chain/db/kv/error.go

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

beacon-chain/db/kv/genesis.go

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

beacon-chain/db/kv/kv.go

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

beacon-chain/db/kv/state_diff_helpers.go

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

beacon-chain/db/kv/wss.go

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

beacon-chain/node/node.go

@@ -535,7 +535,12 @@ func openDB(ctx context.Context, dbPath string, clearer *dbClearer) (*kv.Store,
 	log.WithField("databasePath", dbPath).Info("Checking DB")
 
 	d, err := kv.NewKVStore(ctx, dbPath)
-	if err != nil {
+	if errors.Is(err, kv.ErrStateDiffIncompatible) {
+		log.WithError(err).Warn("Disabling state-diff feature")
+		cfg := features.Get()
+		cfg.EnableStateDiff = false
+		features.Init(cfg)
+	} else if err != nil {
 		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
 	}
 

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

@@ -83,6 +83,7 @@ func TestGetSpec(t *testing.T) {
 	config.ElectraForkEpoch = 107
 	config.FuluForkVersion = []byte("FuluForkVersion")
 	config.FuluForkEpoch = 109
+	config.GloasForkEpoch = 110
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
 	config.GenesisDelay = 24
@@ -134,6 +135,10 @@ func TestGetSpec(t *testing.T) {
 	config.AttestationDueBPS = primitives.BP(122)
 	config.AggregateDueBPS = primitives.BP(123)
 	config.ContributionDueBPS = primitives.BP(124)
+	config.AttestationDueBPSGloas = primitives.BP(126)
+	config.AggregateDueBPSGloas = primitives.BP(127)
+	config.SyncMessageDueBPSGloas = primitives.BP(128)
+	config.ContributionDueBPSGloas = primitives.BP(129)
 	config.TerminalBlockHash = common.HexToHash("TerminalBlockHash")
 	config.TerminalBlockHashActivationEpoch = 72
 	config.TerminalTotalDifficulty = "73"
@@ -215,7 +220,7 @@ func TestGetSpec(t *testing.T) {
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
 	data, ok := resp.Data.(map[string]any)
 	require.Equal(t, true, ok)
-	assert.Equal(t, 187, len(data))
+	assert.Equal(t, 192, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -295,6 +300,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x"+hex.EncodeToString([]byte("FuluForkVersion")), v)
 			case "FULU_FORK_EPOCH":
 				assert.Equal(t, "109", v)
+			case "GLOAS_FORK_EPOCH":
+				assert.Equal(t, "110", v)
 			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
 				assert.Equal(t, "1000", v)
 			case "BLS_WITHDRAWAL_PREFIX":
@@ -479,6 +486,14 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "123", v)
 			case "CONTRIBUTION_DUE_BPS":
 				assert.Equal(t, "124", v)
+			case "ATTESTATION_DUE_BPS_GLOAS":
+				assert.Equal(t, "126", v)
+			case "AGGREGATE_DUE_BPS_GLOAS":
+				assert.Equal(t, "127", v)
+			case "SYNC_MESSAGE_DUE_BPS_GLOAS":
+				assert.Equal(t, "128", v)
+			case "CONTRIBUTION_DUE_BPS_GLOAS":
+				assert.Equal(t, "129", v)
 			case "MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT":
 				assert.Equal(t, "8", v)
 			case "MAX_REQUEST_LIGHT_CLIENT_UPDATES":

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

@@ -48,6 +48,7 @@ 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,18 +35,19 @@ 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
+	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
 }
 
 // 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.
@@ -61,21 +62,28 @@ func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (
 	ctx, cancel := context.WithTimeout(ctx, timeoutDuration)
 	defer cancel() // Important to avoid a context leak
 
-	if ns.SyncChecker.Synced() {
+	// 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 {
 		return &empty.Empty{}, nil
 	}
 	if ns.SyncChecker.Syncing() || ns.SyncChecker.Initialized() {
-		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
-		}
+		// 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 custom success code header: %v", err)
+			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status 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.Error(codes.Unavailable, "node is optimistic")
 	}
 	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
 }

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

@@ -2,6 +2,7 @@ package node
 
 import (
 	"errors"
+	"maps"
 	"testing"
 	"time"
 
@@ -21,6 +22,7 @@ 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"
@@ -187,32 +189,71 @@ 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
-		customStatus uint64
+		isOptimistic bool
 		wantedErr    string
 	}{
 		{
-			name:  "happy path",
-			input: &mockSync.Sync{IsSyncing: false, IsSynced: true},
+			name:         "happy path - synced and not optimistic",
+			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
+			isOptimistic: false,
 		},
 		{
-			name:      "syncing",
-			input:     &mockSync.Sync{IsSyncing: false},
-			wantedErr: "service unavailable",
+			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",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			server := grpc.NewServer()
 			ns := &Server{
-				SyncChecker: tt.input,
+				SyncChecker:           tt.input,
+				OptimisticModeFetcher: &mock.ChainService{Optimistic: tt.isOptimistic},
 			}
 			ethpb.RegisterNodeServer(server, ns)
 			reflection.Register(server)
-			_, err := ns.GetHealth(t.Context(), &ethpb.HealthRequest{SyncingStatus: tt.customStatus})
+
+			// 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{})
 			if tt.wantedErr == "" {
 				require.NoError(t, err)
 				return

beacon-chain/rpc/service.go

@@ -259,18 +259,19 @@ 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,
+		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,
 	}
 	beaconChainServer := &beaconv1alpha1.Server{
 		Ctx:                         s.ctx,

beacon-chain/state/stategen/migrate.go

@@ -137,7 +137,7 @@ func (s *State) migrateToColdHdiff(ctx context.Context, fRoot [32]byte) error {
 		if ctx.Err() != nil {
 			return ctx.Err()
 		}
-		_, lvl, err := s.beaconDB.SlotInDiffTree(slot)
+		offset, lvl, err := s.beaconDB.SlotInDiffTree(slot)
 		if err != nil {
 			log.WithError(err).Errorf("could not determine if slot %d is in diff tree", slot)
 			continue
@@ -145,6 +145,9 @@ func (s *State) migrateToColdHdiff(ctx context.Context, fRoot [32]byte) error {
 		if lvl == -1 {
 			continue
 		}
+		if uint64(slot) == offset {
+			continue
+		}
 		// The state needs to be saved.
 		// Try the epoch boundary cache first.
 		cached, exists, err := s.epochBoundaryStateCache.getBySlot(slot)

changelog/bastin_path-ephemeral-log.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Added a field `path` for the ephemeral log file initialization log.

changelog/farazdagi_fix-hashtree-darwin-amd64.md

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

changelog/james-prysm_update-health-endpoint.md

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

changelog/potuz_hdiff_start_db.md

@@ -0,0 +1,3 @@
+### Added
+
+- Initialize db with state-diff feature flag. 

changelog/terencechain_gloas-duty-timings.md

@@ -0,0 +1,2 @@
+### Added
+- Gloas-specific timing intervals for validator attestation, aggregation, and sync duties.

cmd/beacon-chain/main.go

@@ -160,6 +160,7 @@ var appFlags = []cli.Flag{
 	dasFlags.BackfillOldestSlot,
 	dasFlags.BlobRetentionEpochFlag,
 	flags.BatchVerifierLimit,
+	flags.StateDiffExponents,
 	flags.DisableEphemeralLogFile,
 }
 

cmd/beacon-chain/usage.go

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

config/features/flags.go

@@ -280,6 +280,7 @@ var BeaconChainFlags = combinedFlags([]cli.Flag{
 	DisableQUIC,
 	EnableDiscoveryReboot,
 	enableExperimentalAttestationPool,
+	EnableStateDiff,
 	forceHeadFlag,
 	blacklistRoots,
 	enableHashtree,

config/params/config.go

@@ -91,6 +91,10 @@ type BeaconChainConfig struct {
 	AggregateDueBPS                 primitives.BP    `yaml:"AGGREGATE_DUE_BPS" spec:"true"`                   // AggregateDueBPS defines the aggregate due time in basis points of the slot.
 	SyncMessageDueBPS               primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS" spec:"true"`                // SyncMessageDueBPS defines the sync message due time in basis points of the slot.
 	ContributionDueBPS              primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS" spec:"true"`                // ContributionDueBPS defines the contribution due time in basis points of the slot.
+	AttestationDueBPSGloas          primitives.BP    `yaml:"ATTESTATION_DUE_BPS_GLOAS" spec:"true"`           // AttestationDueBPSGloas defines the attestation due time in basis points of the slot (Gloas).
+	AggregateDueBPSGloas            primitives.BP    `yaml:"AGGREGATE_DUE_BPS_GLOAS" spec:"true"`             // AggregateDueBPSGloas defines the aggregate due time in basis points of the slot (Gloas).
+	SyncMessageDueBPSGloas          primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS_GLOAS" spec:"true"`          // SyncMessageDueBPSGloas defines the sync message due time in basis points of the slot (Gloas).
+	ContributionDueBPSGloas         primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS_GLOAS" spec:"true"`          // ContributionDueBPSGloas defines the contribution due time in basis points of the slot (Gloas).
 
 	// Ethereum PoW parameters.
 	DepositChainID         uint64 `yaml:"DEPOSIT_CHAIN_ID" spec:"true"`         // DepositChainID of the eth1 network. This used for replay protection.
@@ -188,6 +192,7 @@ type BeaconChainConfig struct {
 	ElectraForkEpoch     primitives.Epoch `yaml:"ELECTRA_FORK_EPOCH" spec:"true"`     // ElectraForkEpoch is used to represent the assigned fork epoch for electra.
 	FuluForkVersion      []byte           `yaml:"FULU_FORK_VERSION" spec:"true"`      // FuluForkVersion is used to represent the fork version for fulu.
 	FuluForkEpoch        primitives.Epoch `yaml:"FULU_FORK_EPOCH" spec:"true"`        // FuluForkEpoch is used to represent the assigned fork epoch for fulu.
+	GloasForkEpoch       primitives.Epoch `yaml:"GLOAS_FORK_EPOCH" spec:"true"`       // GloasForkEpoch is used to represent the assigned fork epoch for gloas.
 
 	ForkVersionSchedule map[[fieldparams.VersionLength]byte]primitives.Epoch // Schedule of fork epochs by version.
 	ForkVersionNames    map[[fieldparams.VersionLength]byte]string           // Human-readable names of fork versions.
@@ -343,6 +348,7 @@ func (b *BeaconChainConfig) VersionToForkEpochMap() map[int]primitives.Epoch {
 		version.Deneb:     b.DenebForkEpoch,
 		version.Electra:   b.ElectraForkEpoch,
 		version.Fulu:      b.FuluForkEpoch,
+		version.Gloas:     b.GloasForkEpoch,
 	}
 }
 

config/params/loader.go

@@ -224,6 +224,7 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("ELECTRA_FORK_VERSION: %#x", cfg.ElectraForkVersion),
 		fmt.Sprintf("FULU_FORK_EPOCH: %d", cfg.FuluForkEpoch),
 		fmt.Sprintf("FULU_FORK_VERSION: %#x", cfg.FuluForkVersion),
+		fmt.Sprintf("GLOAS_FORK_EPOCH: %d", cfg.GloasForkEpoch),
 		fmt.Sprintf("EPOCHS_PER_SUBNET_SUBSCRIPTION: %d", cfg.EpochsPerSubnetSubscription),
 		fmt.Sprintf("ATTESTATION_SUBNET_EXTRA_BITS: %d", cfg.AttestationSubnetExtraBits),
 		fmt.Sprintf("ATTESTATION_SUBNET_PREFIX_BITS: %d", cfg.AttestationSubnetPrefixBits),
@@ -246,6 +247,10 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("AGGREGATE_DUE_BPS: %d", cfg.AggregateDueBPS),
 		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS: %d", cfg.SyncMessageDueBPS),
 		fmt.Sprintf("CONTRIBUTION_DUE_BPS: %d", cfg.ContributionDueBPS),
+		fmt.Sprintf("ATTESTATION_DUE_BPS_GLOAS: %d", cfg.AttestationDueBPSGloas),
+		fmt.Sprintf("AGGREGATE_DUE_BPS_GLOAS: %d", cfg.AggregateDueBPSGloas),
+		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS_GLOAS: %d", cfg.SyncMessageDueBPSGloas),
+		fmt.Sprintf("CONTRIBUTION_DUE_BPS_GLOAS: %d", cfg.ContributionDueBPSGloas),
 	}
 
 	if len(cfg.BlobSchedule) > 0 {

config/params/loader_test.go

@@ -24,12 +24,9 @@ import (
 // These are variables that we don't use in Prysm. (i.e. future hardfork, light client... etc)
 // IMPORTANT: Use one field per line and sort these alphabetically to reduce conflicts.
 var placeholderFields = []string{
-	"AGGREGATE_DUE_BPS_GLOAS",
 	"ATTESTATION_DEADLINE",
-	"ATTESTATION_DUE_BPS_GLOAS",
 	"BLOB_SIDECAR_SUBNET_COUNT_FULU",
 	"CELLS_PER_EXT_BLOB",
-	"CONTRIBUTION_DUE_BPS_GLOAS",
 	"EIP6110_FORK_EPOCH",
 	"EIP6110_FORK_VERSION",
 	"EIP7002_FORK_EPOCH",
@@ -45,7 +42,6 @@ var placeholderFields = []string{
 	"EPOCHS_PER_SHUFFLING_PHASE",
 	"FIELD_ELEMENTS_PER_CELL",     // Configured as a constant in config/fieldparams/mainnet.go
 	"FIELD_ELEMENTS_PER_EXT_BLOB", // Configured in proto/ssz_proto_library.bzl
-	"GLOAS_FORK_EPOCH",
 	"GLOAS_FORK_VERSION",
 	"INCLUSION_LIST_SUBMISSION_DEADLINE",
 	"INCLUSION_LIST_SUBMISSION_DUE_BPS",
@@ -60,7 +56,6 @@ var placeholderFields = []string{
 	"PROPOSER_INCLUSION_LIST_CUTOFF",
 	"PROPOSER_INCLUSION_LIST_CUTOFF_BPS",
 	"PROPOSER_SELECTION_GAP",
-	"SYNC_MESSAGE_DUE_BPS_GLOAS",
 	"TARGET_NUMBER_OF_PEERS",
 	"UPDATE_TIMEOUT",
 	"VIEW_FREEZE_CUTOFF_BPS",

config/params/mainnet_config.go

@@ -32,6 +32,8 @@ const (
 	mainnetElectraForkEpoch = 364032 // May 7, 2025, 10:05:11 UTC
 	// Fulu Fork Epoch for mainnet config
 	mainnetFuluForkEpoch = 411392 // December 3, 2025, 09:49:11pm UTC
+	// Gloas Fork Epoch for mainnet config
+	mainnetGloasForkEpoch = math.MaxUint64
 )
 
 var mainnetNetworkConfig = &NetworkConfig{
@@ -121,11 +123,15 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	IntervalsPerSlot:                3,
 
 	// Time-based protocol parameters.
-	ProposerReorgCutoffBPS: primitives.BP(1667),
-	AttestationDueBPS:      primitives.BP(3333),
-	AggregateDueBPS:        primitives.BP(6667),
-	SyncMessageDueBPS:      primitives.BP(3333),
-	ContributionDueBPS:     primitives.BP(6667),
+	ProposerReorgCutoffBPS:  primitives.BP(1667),
+	AttestationDueBPS:       primitives.BP(3333),
+	AggregateDueBPS:         primitives.BP(6667),
+	SyncMessageDueBPS:       primitives.BP(3333),
+	ContributionDueBPS:      primitives.BP(6667),
+	AttestationDueBPSGloas:  primitives.BP(2500),
+	AggregateDueBPSGloas:    primitives.BP(5000),
+	SyncMessageDueBPSGloas:  primitives.BP(2500),
+	ContributionDueBPSGloas: primitives.BP(5000),
 
 	// Ethereum PoW parameters.
 	DepositChainID:         1, // Chain ID of eth1 mainnet.
@@ -235,6 +241,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	ElectraForkEpoch:     mainnetElectraForkEpoch,
 	FuluForkVersion:      []byte{6, 0, 0, 0},
 	FuluForkEpoch:        mainnetFuluForkEpoch,
+	GloasForkEpoch:       mainnetGloasForkEpoch,
 
 	// New values introduced in Altair hard fork 1.
 	// Participation flag indices.

config/params/minimal_config.go

@@ -35,6 +35,10 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	// Time parameters
 	minimalConfig.SecondsPerSlot = 6
 	minimalConfig.SlotDurationMilliseconds = 6000
+	minimalConfig.AttestationDueBPSGloas = 2500
+	minimalConfig.AggregateDueBPSGloas = 5000
+	minimalConfig.SyncMessageDueBPSGloas = 2500
+	minimalConfig.ContributionDueBPSGloas = 5000
 	minimalConfig.MinAttestationInclusionDelay = 1
 	minimalConfig.SlotsPerEpoch = 8
 	minimalConfig.SqrRootSlotsPerEpoch = 2
@@ -98,6 +102,7 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.ElectraForkEpoch = math.MaxUint64
 	minimalConfig.FuluForkVersion = []byte{6, 0, 0, 1}
 	minimalConfig.FuluForkEpoch = math.MaxUint64
+	minimalConfig.GloasForkEpoch = minimalConfig.FarFutureEpoch
 
 	minimalConfig.SyncCommitteeSize = 32
 	minimalConfig.InactivityScoreBias = 4

io/logs/logutil.go

@@ -103,7 +103,7 @@ func ConfigureEphemeralLogFile(datadirPath string, app string) error {
 		AllowedLevels: logrus.AllLevels[:ephemeralLogFileVerbosity+1],
 	})
 
-	logrus.Debug("Ephemeral log file initialized")
+	logrus.WithField("path", logFilePath).Debug("Ephemeral log file initialized")
 	return nil
 }
 

testing/endtoend/BUILD.bazel

@@ -97,6 +97,7 @@ go_test(
         "endtoend_setup_test.go",
         "endtoend_test.go",
         "minimal_e2e_test.go",
+        "minimal_hdiff_e2e_test.go",
         "minimal_slashing_e2e_test.go",
         "slasher_simulator_e2e_test.go",
     ],

testing/endtoend/minimal_hdiff_e2e_test.go

@@ -0,0 +1,16 @@
+package endtoend
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/testing/endtoend/types"
+)
+
+func TestEndToEnd_MinimalConfig_WithStateDiff(t *testing.T) {
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()),
+		types.WithStateDiff(),
+	)
+	r.run()
+}

testing/endtoend/types/types.go

@@ -76,6 +76,15 @@ func WithSSZOnly() E2EConfigOpt {
 	}
 }
 
+func WithStateDiff() E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.BeaconFlags = append(cfg.BeaconFlags,
+			"--enable-state-diff",
+			"--state-diff-exponents=6,5", // Small exponents for quick testing
+		)
+	}
+}
+
 // WithExitEpoch sets a custom epoch for voluntary exit submission.
 // This affects ProposeVoluntaryExit, ValidatorsHaveExited, SubmitWithdrawal, and ValidatorsHaveWithdrawn evaluators.
 func WithExitEpoch(e primitives.Epoch) E2EConfigOpt {

third_party/com_github_offchainlabs_hashtree.patch

@@ -1,7 +1,7 @@
 diff -urN a/BUILD.bazel b/BUILD.bazel
 --- a/BUILD.bazel	1969-12-31 18:00:00.000000000 -0600
 +++ b/BUILD.bazel	2025-01-05 12:00:00.000000000 -0600
-@@ -0,0 +1,89 @@
+@@ -0,0 +1,90 @@
 +load("@io_bazel_rules_go//go:def.bzl", "go_library")
 +
 +go_library(
@@ -32,6 +32,7 @@ diff -urN a/BUILD.bazel b/BUILD.bazel
 +        ],
 +        "@io_bazel_rules_go//go/platform:darwin_amd64": [
 +            "bindings_darwin_amd64.go",
++            "wrapper_darwin_amd64.s",
 +        ],
 +        "//conditions:default": [],
 +    }),

validator/client/aggregate.go

@@ -66,7 +66,7 @@ func (v *validator) SubmitAggregateAndProof(ctx context.Context, slot primitives
 	// As specified in spec, an aggregator should wait until two thirds of the way through slot
 	// to broadcast the best aggregate to the global aggregate channel.
 	// https://github.com/ethereum/consensus-specs/blob/v0.9.3/specs/validator/0_beacon-chain-validator.md#broadcast-aggregate
-	v.waitToSlotTwoThirds(ctx, slot)
+	v.waitUntilAggregateDue(ctx, slot)
 
 	// In a DV setup, selection proofs need to be agreed upon by the DV.
 	// Checking for selection proofs at slot 0 of the epoch will result in an error, as the call to the DV executes slower than the start of this function.
@@ -203,11 +203,18 @@ func (v *validator) signSlotWithSelectionProof(ctx context.Context, pubKey [fiel
 	return sig.Marshal(), nil
 }
 
-// waitToSlotTwoThirds waits until two third through the current slot period
-// such that any attestations from this slot have time to reach the beacon node
-// before creating the aggregated attestation.
-func (v *validator) waitToSlotTwoThirds(ctx context.Context, slot primitives.Slot) {
-	v.waitUntilSlotComponent(ctx, slot, params.BeaconConfig().AggregateDueBPS)
+// waitUntilAggregateDue waits until the configured aggregation due time within the current slot
+// such that any attestations from this slot have time to reach the beacon node before creating
+// the aggregated attestation.
+//
+// Note: Historically this was ~2/3 of the slot, but may differ across forks (e.g. Gloas).
+func (v *validator) waitUntilAggregateDue(ctx context.Context, slot primitives.Slot) {
+	cfg := params.BeaconConfig()
+	component := cfg.AggregateDueBPS
+	if slots.ToEpoch(slot) >= cfg.GloasForkEpoch {
+		component = cfg.AggregateDueBPSGloas
+	}
+	v.waitUntilSlotComponent(ctx, slot, component)
 }
 
 // This returns the signature of validator signing over aggregate and

validator/client/aggregate_test.go

@@ -260,7 +260,7 @@ func TestWaitForSlotTwoThird_WaitCorrectly(t *testing.T) {
 			timeToSleep := params.BeaconConfig().SlotComponentDuration(params.BeaconConfig().AggregateDueBPS)
 
 			twoThirdTime := currentTime.Add(timeToSleep)
-			validator.waitToSlotTwoThirds(t.Context(), numOfSlots)
+			validator.waitUntilAggregateDue(t.Context(), numOfSlots)
 			currentTime = time.Now()
 			assert.Equal(t, twoThirdTime.Unix(), currentTime.Unix())
 		})
@@ -280,7 +280,7 @@ func TestWaitForSlotTwoThird_DoneContext_ReturnsImmediately(t *testing.T) {
 			expectedTime := time.Now()
 			ctx, cancel := context.WithCancel(t.Context())
 			cancel()
-			validator.waitToSlotTwoThirds(ctx, numOfSlots)
+			validator.waitUntilAggregateDue(ctx, numOfSlots)
 			currentTime = time.Now()
 			assert.Equal(t, expectedTime.Unix(), currentTime.Unix())
 		})

validator/client/attest.go

@@ -37,7 +37,7 @@ func (v *validator) SubmitAttestation(ctx context.Context, slot primitives.Slot,
 	defer span.End()
 	span.SetAttributes(trace.StringAttribute("validator", fmt.Sprintf("%#x", pubKey)))
 
-	v.waitOneThirdOrValidBlock(ctx, slot)
+	v.waitUntilAttestationDueOrValidBlock(ctx, slot)
 
 	var b strings.Builder
 	if err := b.WriteByte(byte(iface.RoleAttester)); err != nil {
@@ -259,12 +259,12 @@ func (v *validator) setHighestSlot(slot primitives.Slot) {
 	}
 }
 
-// waitOneThirdOrValidBlock waits until (a) or (b) whichever comes first:
+// waitUntilAttestationDueOrValidBlock waits until (a) or (b) whichever comes first:
 //
 //	(a) the validator has received a valid block that is the same slot as input slot
-//	(b) one-third of the slot has transpired (SECONDS_PER_SLOT / 3 seconds after the start of slot)
-func (v *validator) waitOneThirdOrValidBlock(ctx context.Context, slot primitives.Slot) {
-	ctx, span := trace.StartSpan(ctx, "validator.waitOneThirdOrValidBlock")
+//	(b) the configured attestation due time has transpired (as basis points of the slot duration)
+func (v *validator) waitUntilAttestationDueOrValidBlock(ctx context.Context, slot primitives.Slot) {
+	ctx, span := trace.StartSpan(ctx, "validator.waitUntilAttestationDueOrValidBlock")
 	defer span.End()
 
 	// Don't need to wait if requested slot is the same as highest valid slot.
@@ -272,7 +272,12 @@ func (v *validator) waitOneThirdOrValidBlock(ctx context.Context, slot primitive
 		return
 	}
 
-	finalTime, err := v.slotComponentDeadline(slot, params.BeaconConfig().AttestationDueBPS)
+	cfg := params.BeaconConfig()
+	component := cfg.AttestationDueBPS
+	if slots.ToEpoch(slot) >= cfg.GloasForkEpoch {
+		component = cfg.AttestationDueBPSGloas
+	}
+	finalTime, err := v.slotComponentDeadline(slot, component)
 	if err != nil {
 		log.WithError(err).WithField("slot", slot).Error("Slot overflows, unable to wait for attestation deadline")
 		return

validator/client/attest_test.go

@@ -706,7 +706,7 @@ func TestServer_WaitToSlotOneThird_CanWait(t *testing.T) {
 
 	timeToSleep := params.BeaconConfig().SecondsPerSlot / 3
 	oneThird := currentTime.Add(time.Duration(timeToSleep) * time.Second)
-	v.waitOneThirdOrValidBlock(t.Context(), currentSlot)
+	v.waitUntilAttestationDueOrValidBlock(t.Context(), currentSlot)
 
 	if oneThird.Sub(time.Now()) > 10*time.Millisecond { // Allow for small diff due to execution time.
 		t.Errorf("Wanted %s time for slot one third but got %s", oneThird, currentTime)
@@ -724,7 +724,7 @@ func TestServer_WaitToSlotOneThird_SameReqSlot(t *testing.T) {
 		highestValidSlot: currentSlot,
 	}
 
-	v.waitOneThirdOrValidBlock(t.Context(), currentSlot)
+	v.waitUntilAttestationDueOrValidBlock(t.Context(), currentSlot)
 
 	if currentTime.Sub(time.Now()) > 10*time.Millisecond { // Allow for small diff due to execution time.
 		t.Errorf("Wanted %s time for slot one third but got %s", time.Now(), currentTime)
@@ -750,7 +750,7 @@ func TestServer_WaitToSlotOneThird_ReceiveBlockSlot(t *testing.T) {
 		v.slotFeed.Send(currentSlot)
 	})
 
-	v.waitOneThirdOrValidBlock(t.Context(), currentSlot)
+	v.waitUntilAttestationDueOrValidBlock(t.Context(), currentSlot)
 
 	if currentTime.Sub(time.Now()) > 10*time.Millisecond { // Allow for small diff due to execution time.
 		t.Errorf("Wanted %s time for slot one third but got %s", time.Now(), currentTime)

validator/client/sync_committee.go

@@ -29,7 +29,7 @@ func (v *validator) SubmitSyncCommitteeMessage(ctx context.Context, slot primiti
 	defer span.End()
 	span.SetAttributes(trace.StringAttribute("validator", fmt.Sprintf("%#x", pubKey)))
 
-	v.waitOneThirdOrValidBlock(ctx, slot)
+	v.waitUntilAttestationDueOrValidBlock(ctx, slot)
 
 	res, err := v.validatorClient.SyncMessageBlockRoot(ctx, &emptypb.Empty{})
 	if err != nil {
@@ -127,7 +127,12 @@ func (v *validator) SubmitSignedContributionAndProof(ctx context.Context, slot p
 		return
 	}
 
-	v.waitUntilSlotComponent(ctx, slot, params.BeaconConfig().ContributionDueBPS)
+	cfg := params.BeaconConfig()
+	component := cfg.ContributionDueBPS
+	if slots.ToEpoch(slot) >= cfg.GloasForkEpoch {
+		component = cfg.ContributionDueBPSGloas
+	}
+	v.waitUntilSlotComponent(ctx, slot, component)
 
 	coveredSubnets := make(map[uint64]bool)
 	for i, comIdx := range indexRes.Indices {

validator/client/wait_helpers.go

@@ -51,12 +51,20 @@ func (v *validator) slotComponentSpanName(component primitives.BP) string {
 	switch component {
 	case cfg.AttestationDueBPS:
 		return "validator.waitAttestationWindow"
+	case cfg.AttestationDueBPSGloas:
+		return "validator.waitAttestationWindow"
 	case cfg.AggregateDueBPS:
 		return "validator.waitAggregateWindow"
+	case cfg.AggregateDueBPSGloas:
+		return "validator.waitAggregateWindow"
 	case cfg.SyncMessageDueBPS:
 		return "validator.waitSyncMessageWindow"
+	case cfg.SyncMessageDueBPSGloas:
+		return "validator.waitSyncMessageWindow"
 	case cfg.ContributionDueBPS:
 		return "validator.waitContributionWindow"
+	case cfg.ContributionDueBPSGloas:
+		return "validator.waitContributionWindow"
 	case cfg.ProposerReorgCutoffBPS:
 		return "validator.waitProposerReorgWindow"
 	default: