Potuz's feedback

This PR implements
[process_slot](https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/beacon-chain.md#modified-process_slot)
and spec tests

beacon-chain/core/blocks/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/blocks/proposer_slashing.go

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

beacon-chain/core/gloas/BUILD.bazel

@@ -5,12 +5,14 @@ go_library(
     srcs = [
         "bid.go",
         "pending_payment.go",
+        "proposer_slashing.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -29,6 +31,7 @@ go_test(
     srcs = [
         "bid_test.go",
         "pending_payment_test.go",
+        "proposer_slashing_test.go",
     ],
     embed = [":go_default_library"],
     deps = [

beacon-chain/core/gloas/proposer_slashing.go

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

beacon-chain/core/gloas/proposer_slashing_test.go

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

beacon-chain/core/transition/BUILD.bazel

@@ -71,6 +71,7 @@ go_test(
         "state_test.go",
         "trailing_slot_state_cache_test.go",
         "transition_fuzz_test.go",
+        "transition_gloas_test.go",
         "transition_no_verify_sig_test.go",
         "transition_test.go",
     ],
@@ -106,6 +107,7 @@ go_test(
         "//time/slots:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/transition/transition.go

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

beacon-chain/core/transition/transition_gloas_test.go

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

beacon-chain/state/interfaces_gloas.go

@@ -11,6 +11,7 @@ type writeOnlyGloasFields interface {
 	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
 	RotateBuilderPendingPayments() error
 	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
+	UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error
 }
 
 type readOnlyGloasFields interface {

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

@@ -27,7 +27,7 @@ func (b *BeaconState) RotateBuilderPendingPayments() error {
 	copy(b.builderPendingPayments[:slotsPerEpoch], b.builderPendingPayments[slotsPerEpoch:2*slotsPerEpoch])
 
 	for i := slotsPerEpoch; i < primitives.Slot(len(b.builderPendingPayments)); i++ {
-		b.builderPendingPayments[i] = emptyPayment()
+		b.builderPendingPayments[i] = ethpb.EmptyBuilderPendingPayment
 	}
 
 	b.markFieldAsDirty(types.BuilderPendingPayments)
@@ -62,17 +62,6 @@ func (b *BeaconState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.Build
 	return nil
 }
 
-func emptyPayment() *ethpb.BuilderPendingPayment {
-	return &ethpb.BuilderPendingPayment{
-		Weight: 0,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-			Amount:       0,
-			BuilderIndex: 0,
-		},
-	}
-}
-
 // SetExecutionPayloadBid sets the latest execution payload bid in the state.
 func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
 	if b.version < version.Gloas {
@@ -119,8 +108,34 @@ func (b *BeaconState) SetBuilderPendingPayment(index primitives.Slot, payment *e
 		return fmt.Errorf("builder pending payments index %d out of range (len=%d)", index, len(b.builderPendingPayments))
 	}
 
-	b.builderPendingPayments[index] = ethpb.CopyBuilderPendingPayment(payment)
+	if payment == ethpb.EmptyBuilderPendingPayment {
+		b.builderPendingPayments[index] = payment
+	} else {
+		b.builderPendingPayments[index] = ethpb.CopyBuilderPendingPayment(payment)
+	}
 
 	b.markFieldAsDirty(types.BuilderPendingPayments)
 	return nil
 }
+
+// UpdateExecutionPayloadAvailabilityAtIndex updates the execution payload availability bit at a specific index.
+func (b *BeaconState) UpdateExecutionPayloadAvailabilityAtIndex(idx uint64, val byte) error {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	byteIndex := idx / 8
+	bitIndex := idx % 8
+
+	if byteIndex >= uint64(len(b.executionPayloadAvailability)) {
+		return fmt.Errorf("bit index %d (byte index %d) out of range for execution payload availability length %d", idx, byteIndex, len(b.executionPayloadAvailability))
+	}
+
+	if val != 0 {
+		b.executionPayloadAvailability[byteIndex] |= (1 << bitIndex)
+	} else {
+		b.executionPayloadAvailability[byteIndex] &^= (1 << bitIndex)
+	}
+
+	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
+	return nil
+}

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

@@ -247,3 +247,44 @@ func TestAppendBuilderPendingWithdrawals_UnsupportedVersion(t *testing.T) {
 	err := st.AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal{{}})
 	require.ErrorContains(t, "AppendBuilderPendingWithdrawals", err)
 }
+
+func TestUpdateExecutionPayloadAvailabilityAtIndex_SetAndClear(t *testing.T) {
+	st := newGloasStateWithAvailability(t, make([]byte, 1024))
+
+	otherIdx := uint64(8) // byte 1, bit 0
+	idx := uint64(9)      // byte 1, bit 1
+
+	require.NoError(t, st.UpdateExecutionPayloadAvailabilityAtIndex(otherIdx, 1))
+	require.Equal(t, byte(0x01), st.executionPayloadAvailability[1])
+
+	require.NoError(t, st.UpdateExecutionPayloadAvailabilityAtIndex(idx, 1))
+	require.Equal(t, byte(0x03), st.executionPayloadAvailability[1])
+
+	require.NoError(t, st.UpdateExecutionPayloadAvailabilityAtIndex(idx, 0))
+	require.Equal(t, byte(0x01), st.executionPayloadAvailability[1])
+}
+
+func TestUpdateExecutionPayloadAvailabilityAtIndex_OutOfRange(t *testing.T) {
+	st := newGloasStateWithAvailability(t, make([]byte, 1024))
+
+	idx := uint64(len(st.executionPayloadAvailability)) * 8
+	err := st.UpdateExecutionPayloadAvailabilityAtIndex(idx, 1)
+	require.ErrorContains(t, "out of range", err)
+
+	for _, b := range st.executionPayloadAvailability {
+		if b != 0 {
+			t.Fatalf("execution payload availability mutated on error")
+		}
+	}
+}
+
+func newGloasStateWithAvailability(t *testing.T, availability []byte) *BeaconState {
+	t.Helper()
+
+	st, err := InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
+		ExecutionPayloadAvailability: availability,
+	})
+	require.NoError(t, err)
+
+	return st.(*BeaconState)
+}

changelog/james-prysm_longer-e2e-sync-evaluator.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- adding a optimistic check for e2e evlauator on synced head, it may be slower post fulu to sync. 

changelog/t_gloas-process-proposer-slashing.md

@@ -0,0 +1,2 @@
+### Added
+- Implement modified proposer slashing for gloas

changelog/t_gloas_process-slot.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add slot processing with execution payload availability updates

proto/prysm/v1alpha1/BUILD.bazel

@@ -371,6 +371,7 @@ go_library(
         "beacon_block.go",
         "cloners.go",
         "eip_7521.go",
+        "empties.go",
         "gloas.go",
         "log.go",
         "sync_committee_mainnet.go",

proto/prysm/v1alpha1/empties.go

@@ -0,0 +1,8 @@
+package eth
+
+// EmptyBuilderPendingPayment is a shared zero-value payment used to clear entries.
+var EmptyBuilderPendingPayment = &BuilderPendingPayment{
+	Withdrawal: &BuilderPendingWithdrawal{
+		FeeRecipient: make([]byte, 20),
+	},
+}

testing/endtoend/endtoend_test.go

@@ -289,45 +289,10 @@ func (r *testRunner) waitForMatchingHead(ctx context.Context, timeout time.Durat
 				return errors.Wrap(err, "unexpected error requesting head block root from 'ref' beacon node")
 			}
 			if bytesutil.ToBytes32(cResp.HeadBlockRoot) == bytesutil.ToBytes32(rResp.HeadBlockRoot) {
-				// Head matches, now wait for node to exit optimistic mode.
-				// For Fulu, the execution client may take additional time to sync and verify payloads.
-				// Give extra time (up to 2 minutes) for optimistic status to clear.
-				return r.waitForNonOptimistic(ctx, 2*time.Minute, check)
-			}
-		}
-	}
-}
-
-// waitForNonOptimistic waits for a node to exit optimistic mode, with a bounded timeout.
-// If the timeout is reached, it logs a warning but does not fail - the evaluator will
-// handle optimistic nodes gracefully by skipping finalized/justified checks.
-func (r *testRunner) waitForNonOptimistic(ctx context.Context, timeout time.Duration, conn *grpc.ClientConn) error {
-	start := time.Now()
-	deadline := start.Add(timeout)
-	checkClient := eth.NewBeaconChainClient(conn)
-
-	for time.Now().Before(deadline) {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-			cResp, err := checkClient.GetChainHead(ctx, &emptypb.Empty{})
-			if err != nil {
-				// If we can't get chain head, just continue - head already matched
-				time.Sleep(100 * time.Millisecond)
-				continue
-			}
-			if !cResp.OptimisticStatus {
-				log.Infof("Node exited optimistic mode after %s", time.Since(start))
 				return nil
 			}
-			time.Sleep(100 * time.Millisecond)
 		}
 	}
-
-	// Timeout reached but node is still optimistic - this is OK, evaluator handles it
-	log.Warnf("Node still in optimistic mode after %s, continuing anyway (evaluator will handle)", timeout)
-	return nil
 }
 
 func (r *testRunner) testCheckpointSync(ctx context.Context, g *errgroup.Group, i int, conns []*grpc.ClientConn, bnAPI, enr, minerEnr string) error {

testing/endtoend/evaluators/node.go

@@ -129,12 +129,11 @@ func finishedSyncing(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) e
 }
 
 func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
-	headSlots := make([]primitives.Slot, len(conns))
+	headEpochs := make([]primitives.Epoch, len(conns))
 	justifiedRoots := make([][]byte, len(conns))
 	prevJustifiedRoots := make([][]byte, len(conns))
 	finalizedRoots := make([][]byte, len(conns))
 	chainHeads := make([]*eth.ChainHead, len(conns))
-	optimisticStatus := make([]bool, len(conns))
 	g, _ := errgroup.WithContext(context.Background())
 
 	for i, conn := range conns {
@@ -146,12 +145,11 @@ func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientCo
 			if err != nil {
 				return errors.Wrapf(err, "connection number=%d", conIdx)
 			}
-			headSlots[conIdx] = chainHead.HeadSlot
+			headEpochs[conIdx] = chainHead.HeadEpoch
 			justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
 			prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
 			finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
 			chainHeads[conIdx] = chainHead
-			optimisticStatus[conIdx] = chainHead.OptimisticStatus
 			return nil
 		})
 	}
@@ -160,26 +158,14 @@ func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientCo
 	}
 
 	for i := range conns {
-		// Allow head slots to differ by at most 2 slots to account for timing
-		// differences when querying nodes and chain advancement during evaluation.
-		slotDiff := headSlots[0] - headSlots[i]
-		if headSlots[i] > headSlots[0] {
-			slotDiff = headSlots[i] - headSlots[0]
-		}
-		if slotDiff > 2 {
+		if headEpochs[0] != headEpochs[i] {
 			return fmt.Errorf(
-				"received conflicting head slots on node %d, expected %d (±2), received %d",
+				"received conflicting head epochs on node %d, expected %d, received %d",
 				i,
-				headSlots[0],
-				headSlots[i],
+				headEpochs[0],
+				headEpochs[i],
 			)
 		}
-		// Skip finalized/justified checks for nodes in optimistic mode.
-		// Optimistic nodes haven't verified execution payloads yet, so their
-		// finalized/justified state may lag behind fully verified nodes.
-		if optimisticStatus[i] {
-			continue
-		}
 		if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
 			return fmt.Errorf(
 				"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",

testing/spectest/mainnet/BUILD.bazel

@@ -202,6 +202,8 @@ go_test(
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_header_test.go",
+        "gloas__operations__proposer_slashing_test.go",
+        "gloas__sanity__slots_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -282,6 +284,7 @@ go_test(
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
         "//testing/spectest/shared/gloas/epoch_processing:go_default_library",
         "//testing/spectest/shared/gloas/operations:go_default_library",
+        "//testing/spectest/shared/gloas/sanity:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

testing/spectest/mainnet/gloas__operations__proposer_slashing_test.go

@@ -0,0 +1,11 @@
+package mainnet
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
+)
+
+func TestMainnet_Gloas_Operations_ProposerSlashing(t *testing.T) {
+	operations.RunProposerSlashingTest(t, "mainnet")
+}

testing/spectest/mainnet/gloas__sanity__slots_test.go

@@ -0,0 +1,11 @@
+package mainnet
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/sanity"
+)
+
+func TestMainnet_Gloas_Sanity_Slots(t *testing.T) {
+	sanity.RunSlotProcessingTests(t, "mainnet")
+}

testing/spectest/minimal/BUILD.bazel

@@ -208,6 +208,8 @@ go_test(
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_bid_test.go",
+        "gloas__operations__proposer_slashing_test.go",
+        "gloas__sanity__slots_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -292,6 +294,7 @@ go_test(
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
         "//testing/spectest/shared/gloas/epoch_processing:go_default_library",
         "//testing/spectest/shared/gloas/operations:go_default_library",
+        "//testing/spectest/shared/gloas/sanity:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

testing/spectest/minimal/gloas__operations__proposer_slashing_test.go

@@ -0,0 +1,11 @@
+package minimal
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
+)
+
+func TestMinimal_Gloas_Operations_ProposerSlashing(t *testing.T) {
+	operations.RunProposerSlashingTest(t, "minimal")
+}

testing/spectest/minimal/gloas__sanity__slots_test.go

@@ -0,0 +1,11 @@
+package minimal
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/sanity"
+)
+
+func TestMinimal_Gloas_Sanity_Slots(t *testing.T) {
+	sanity.RunSlotProcessingTests(t, "minimal")
+}

testing/spectest/shared/gloas/operations/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
     srcs = [
         "execution_payload_bid.go",
         "helpers.go",
+        "proposer_slashing.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
     visibility = ["//visibility:public"],

testing/spectest/shared/gloas/operations/helpers.go

@@ -3,6 +3,8 @@ package operations
 import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
@@ -13,3 +15,19 @@ func sszToState(b []byte) (state.BeaconState, error) {
 	}
 	return state_native.InitializeFromProtoGloas(base)
 }
+
+func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
+	base := &ethpb.BeaconBlockGloas{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: base})
+}
+
+func sszToBlockBody(b []byte) (interfaces.ReadOnlyBeaconBlockBody, error) {
+	base := &ethpb.BeaconBlockBodyGloas{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.NewBeaconBlockBody(base)
+}

testing/spectest/shared/gloas/operations/proposer_slashing.go

@@ -0,0 +1,28 @@
+package operations
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
+)
+
+func blockWithProposerSlashing(ssz []byte) (interfaces.SignedBeaconBlock, error) {
+	ps := &ethpb.ProposerSlashing{}
+	if err := ps.UnmarshalSSZ(ssz); err != nil {
+		return nil, err
+	}
+	b := &ethpb.SignedBeaconBlockGloas{
+		Block: &ethpb.BeaconBlockGloas{
+			Body: &ethpb.BeaconBlockBodyGloas{ProposerSlashings: []*ethpb.ProposerSlashing{ps}},
+		},
+	}
+	return blocks.NewSignedBeaconBlock(b)
+}
+
+func RunProposerSlashingTest(t *testing.T, config string) {
+	common.RunProposerSlashingTest(t, config, version.String(version.Gloas), blockWithProposerSlashing, sszToState)
+}

testing/spectest/shared/gloas/sanity/BUILD.bazel

@@ -0,0 +1,19 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    testonly = True,
+    srcs = ["slot_processing.go"],
+    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/sanity",
+    visibility = ["//testing/spectest:__subpackages__"],
+    deps = [
+        "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/spectest/utils:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_golang_snappy//:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+    ],
+)

testing/spectest/shared/gloas/sanity/slot_processing.go

@@ -0,0 +1,61 @@
+package sanity
+
+import (
+	"context"
+	"strconv"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/golang/snappy"
+	"google.golang.org/protobuf/proto"
+)
+
+func init() {
+	transition.SkipSlotCache.Disable()
+}
+
+// RunSlotProcessingTests executes "sanity/slots" tests.
+func RunSlotProcessingTests(t *testing.T, config string) {
+	require.NoError(t, utils.SetConfig(t, config))
+
+	testFolders, testsFolderPath := utils.TestFolders(t, config, "gloas", "sanity/slots/pyspec_tests")
+
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
+			require.NoError(t, err)
+			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			base := &ethpb.BeaconStateGloas{}
+			require.NoError(t, base.UnmarshalSSZ(preBeaconStateSSZ), "Failed to unmarshal")
+			beaconState, err := state_native.InitializeFromProtoGloas(base)
+			require.NoError(t, err)
+
+			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "slots.yaml")
+			require.NoError(t, err)
+			fileStr := string(file)
+			slotsCount, err := strconv.ParseUint(fileStr[:len(fileStr)-5], 10, 64)
+			require.NoError(t, err)
+
+			postBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "post.ssz_snappy")
+			require.NoError(t, err)
+			postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			postBeaconState := &ethpb.BeaconStateGloas{}
+			require.NoError(t, postBeaconState.UnmarshalSSZ(postBeaconStateSSZ), "Failed to unmarshal")
+			postState, err := transition.ProcessSlots(context.Background(), beaconState, beaconState.Slot().Add(slotsCount))
+			require.NoError(t, err)
+
+			pbState, err := state_native.ProtobufBeaconStateGloas(postState.ToProto())
+			require.NoError(t, err)
+			if !proto.Equal(pbState, postBeaconState) {
+				t.Fatal("Did not receive expected post state")
+			}
+		})
+	}
+}