skip eth1data voting after electra

beacon-chain/core/helpers/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "beacon_committee.go",
         "block.go",
         "genesis.go",
+        "legacy.go",
         "metrics.go",
         "randao.go",
         "rewards_penalties.go",
@@ -52,6 +53,7 @@ go_test(
         "attestation_test.go",
         "beacon_committee_test.go",
         "block_test.go",
+        "legacy_test.go",
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
         "randao_test.go",
@@ -86,5 +88,6 @@ go_test(
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_stretchr_testify//require:go_default_library",
     ],
 )

beacon-chain/core/helpers/legacy.go

@@ -0,0 +1,32 @@
+package helpers
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+// IsLegacyDepositProcessPeriod determines if the current state should use the legacy deposit process.
+func IsLegacyDepositProcessPeriod(beaconState state.BeaconState, canonicalEth1Data *ethpb.Eth1Data) bool {
+	// Before the Electra upgrade, always use the legacy deposit process.
+	if beaconState.Version() < version.Electra {
+		return true
+	}
+
+	// Should not happen, but if the canonicalEth1Data is nil
+	// default to legacy
+	if canonicalEth1Data == nil {
+		return true
+	}
+
+	// Handle the transition period between the legacy and the new deposit process.
+	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		// If we can't get the deposit requests start index,
+		// we should default to the legacy deposit process.
+		return true
+	}
+	eth1DepositIndexLimit := math.Min(canonicalEth1Data.DepositCount, requestsStartIndex)
+	return beaconState.Eth1DepositIndex() < eth1DepositIndexLimit
+}

beacon-chain/core/helpers/legacy_test.go

@@ -0,0 +1,111 @@
+package helpers_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsLegacyDepositProcessPeriod(t *testing.T) {
+	tests := []struct {
+		name              string
+		state             state.BeaconState
+		canonicalEth1Data *ethpb.Eth1Data
+		want              bool
+	}{
+		{
+			name: "pre-electra",
+			state: func() state.BeaconState {
+				st, err := state_native.InitializeFromProtoDeneb(&ethpb.BeaconStateDeneb{
+					Eth1Data: &ethpb.Eth1Data{
+						BlockHash:    []byte("0x0"),
+						DepositRoot:  make([]byte, 32),
+						DepositCount: 5,
+					},
+					Eth1DepositIndex: 1,
+				})
+				require.NoError(t, err)
+				return st
+			}(),
+			canonicalEth1Data: &ethpb.Eth1Data{
+				BlockHash:    []byte("0x0"),
+				DepositRoot:  make([]byte, 32),
+				DepositCount: 5,
+			},
+			want: true,
+		},
+		{
+			name: "nil canonicalEth1Data defaults to legacy",
+			state: func() state.BeaconState {
+				st, err := state_native.InitializeFromProtoDeneb(&ethpb.BeaconStateDeneb{
+					Eth1Data: &ethpb.Eth1Data{
+						BlockHash:    []byte("0x0"),
+						DepositRoot:  make([]byte, 32),
+						DepositCount: 5,
+					},
+					Eth1DepositIndex: 1,
+				})
+				require.NoError(t, err)
+				return st
+			}(),
+			canonicalEth1Data: nil,
+			want:              true,
+		},
+		{
+			name: "post-electra, pending deposits from pre-electra",
+			state: func() state.BeaconState {
+				st, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
+					Eth1Data: &ethpb.Eth1Data{
+						BlockHash:    []byte("0x0"),
+						DepositRoot:  make([]byte, 32),
+						DepositCount: 5,
+					},
+					DepositRequestsStartIndex: math.MaxUint64,
+					Eth1DepositIndex:          1,
+				})
+				require.NoError(t, err)
+				return st
+			}(),
+			canonicalEth1Data: &ethpb.Eth1Data{
+				BlockHash:    []byte("0x0"),
+				DepositRoot:  make([]byte, 32),
+				DepositCount: 5,
+			},
+			want: true,
+		},
+		{
+			name: "post-electra, no pending deposits from pre-alpaca",
+			state: func() state.BeaconState {
+				st, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
+					Eth1Data: &ethpb.Eth1Data{
+						BlockHash:    []byte("0x0"),
+						DepositRoot:  make([]byte, 32),
+						DepositCount: 5,
+					},
+					DepositRequestsStartIndex: 1,
+					Eth1DepositIndex:          5,
+				})
+				require.NoError(t, err)
+				return st
+			}(),
+			canonicalEth1Data: &ethpb.Eth1Data{
+				BlockHash:    []byte("0x0"),
+				DepositRoot:  make([]byte, 32),
+				DepositCount: 5,
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := helpers.IsLegacyDepositProcessPeriod(tt.state, tt.canonicalEth1Data); got != tt.want {
+				t.Errorf("isLegacyDepositProcessPeriod() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

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

@@ -7,6 +7,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -98,7 +99,7 @@ func (vs *Server) deposits(
 	// as the legacy deposit process is deprecated. (EIP-6110)
 	// NOTE: During the transition period, the legacy deposit process
 	// may still be active and managed. This function handles that scenario.
-	if !isLegacyDepositProcessPeriod(beaconState, canonicalEth1Data) {
+	if !helpers.IsLegacyDepositProcessPeriod(beaconState, canonicalEth1Data) {
 		return []*ethpb.Deposit{}, nil
 	}
 
@@ -285,21 +286,3 @@ func shouldRebuildTrie(totalDepCount, unFinalizedDeps uint64) bool {
 	unFinalizedCompute := unFinalizedDeps * params.BeaconConfig().DepositContractTreeDepth
 	return unFinalizedCompute > totalDepCount
 }
-
-// isLegacyDepositProcessPeriod determines if the current state should use the legacy deposit process.
-func isLegacyDepositProcessPeriod(beaconState state.BeaconState, canonicalEth1Data *ethpb.Eth1Data) bool {
-	// Before the Electra upgrade, always use the legacy deposit process.
-	if beaconState.Version() < version.Electra {
-		return true
-	}
-
-	// Handle the transition period between the legacy and the new deposit process.
-	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
-	if err != nil {
-		// If we can't get the deposit requests start index,
-		// we should default to the legacy deposit process.
-		return true
-	}
-	eth1DepositIndexLimit := math.Min(canonicalEth1Data.DepositCount, requestsStartIndex)
-	return beaconState.Eth1DepositIndex() < eth1DepositIndexLimit
-}

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

@@ -2,14 +2,12 @@ package validator
 
 import (
 	"context"
-	"math"
 	"math/big"
 	"testing"
 
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositsnapshot"
 	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/container/trie"
@@ -214,85 +212,3 @@ func TestProposer_PendingDeposits_Electra(t *testing.T) {
 	assert.Equal(t, 0, len(deposits), "Received unexpected number of pending deposits")
 
 }
-
-func TestIsLegacyDepositProcessPeriod(t *testing.T) {
-	tests := []struct {
-		name              string
-		state             state.BeaconState
-		canonicalEth1Data *ethpb.Eth1Data
-		want              bool
-	}{
-		{
-			name: "pre-electra",
-			state: func() state.BeaconState {
-				st, err := state_native.InitializeFromProtoDeneb(&ethpb.BeaconStateDeneb{
-					Eth1Data: &ethpb.Eth1Data{
-						BlockHash:    []byte("0x0"),
-						DepositRoot:  make([]byte, 32),
-						DepositCount: 5,
-					},
-					Eth1DepositIndex: 1,
-				})
-				require.NoError(t, err)
-				return st
-			}(),
-			canonicalEth1Data: &ethpb.Eth1Data{
-				BlockHash:    []byte("0x0"),
-				DepositRoot:  make([]byte, 32),
-				DepositCount: 5,
-			},
-			want: true,
-		},
-		{
-			name: "post-electra, pending deposits from pre-electra",
-			state: func() state.BeaconState {
-				st, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
-					Eth1Data: &ethpb.Eth1Data{
-						BlockHash:    []byte("0x0"),
-						DepositRoot:  make([]byte, 32),
-						DepositCount: 5,
-					},
-					DepositRequestsStartIndex: math.MaxUint64,
-					Eth1DepositIndex:          1,
-				})
-				require.NoError(t, err)
-				return st
-			}(),
-			canonicalEth1Data: &ethpb.Eth1Data{
-				BlockHash:    []byte("0x0"),
-				DepositRoot:  make([]byte, 32),
-				DepositCount: 5,
-			},
-			want: true,
-		},
-		{
-			name: "post-electra, no pending deposits from pre-alpaca",
-			state: func() state.BeaconState {
-				st, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
-					Eth1Data: &ethpb.Eth1Data{
-						BlockHash:    []byte("0x0"),
-						DepositRoot:  make([]byte, 32),
-						DepositCount: 5,
-					},
-					DepositRequestsStartIndex: 1,
-					Eth1DepositIndex:          5,
-				})
-				require.NoError(t, err)
-				return st
-			}(),
-			canonicalEth1Data: &ethpb.Eth1Data{
-				BlockHash:    []byte("0x0"),
-				DepositRoot:  make([]byte, 32),
-				DepositCount: 5,
-			},
-			want: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := isLegacyDepositProcessPeriod(tt.state, tt.canonicalEth1Data); got != tt.want {
-				t.Errorf("isLegacyDepositProcessPeriod() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

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

@@ -7,6 +7,7 @@ import (
 	"github.com/pkg/errors"
 	fastssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -30,10 +31,17 @@ import (
 //   - Otherwise:
 //   - Determine the vote with the highest count. Prefer the vote with the highest eth1 block height in the event of a tie.
 //   - This vote's block is the eth1 block to use for the block proposal.
+//
+// After Electra and eth1 deposit transition period voting will no longer be needed
 func (vs *Server) eth1DataMajorityVote(ctx context.Context, beaconState state.BeaconState) (*ethpb.Eth1Data, error) {
 	ctx, cancel := context.WithTimeout(ctx, eth1dataTimeout)
 	defer cancel()
 
+	// post eth1 deposits, the Eth 1 data will then be frozen
+	if !helpers.IsLegacyDepositProcessPeriod(beaconState, vs.HeadFetcher.HeadETH1Data()) {
+		return vs.HeadFetcher.HeadETH1Data(), nil
+	}
+
 	slot := beaconState.Slot()
 	votingPeriodStartTime := vs.slotStartTime(slot)
 

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

@@ -2698,6 +2698,44 @@ func TestProposer_Eth1Data_MajorityVote(t *testing.T) {
 		expectedHash := []byte("eth1data")
 		assert.DeepEqual(t, expectedHash, hash)
 	})
+
+	t.Run("post electra the head eth1data should be returned", func(t *testing.T) {
+		p := mockExecution.New().
+			InsertBlock(50, earliestValidTime, []byte("earliest")).
+			InsertBlock(100, latestValidTime, []byte("latest"))
+		p.Eth1Data = &ethpb.Eth1Data{
+			BlockHash: []byte("eth1data"),
+		}
+
+		depositCache, err := depositsnapshot.New()
+		require.NoError(t, err)
+
+		beaconState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
+			Slot: slot,
+			Eth1DataVotes: []*ethpb.Eth1Data{
+				{BlockHash: []byte("electra"), DepositCount: 1},
+			},
+		})
+		require.NoError(t, err)
+
+		ps := &Server{
+			ChainStartFetcher: p,
+			Eth1InfoFetcher:   p,
+			Eth1BlockFetcher:  p,
+			BlockFetcher:      p,
+			DepositFetcher:    depositCache,
+			HeadFetcher:       &mock.ChainService{ETH1Data: &ethpb.Eth1Data{BlockHash: []byte("legacy"), DepositCount: 0}},
+		}
+
+		ctx := context.Background()
+		majorityVoteEth1Data, err := ps.eth1DataMajorityVote(ctx, beaconState)
+		require.NoError(t, err)
+
+		hash := majorityVoteEth1Data.BlockHash
+
+		expectedHash := []byte("legacy")
+		assert.DeepEqual(t, expectedHash, hash)
+	})
 }
 
 func TestProposer_FilterAttestation(t *testing.T) {

changelog/james-prysm_electra-eth1voting.md

@@ -0,0 +1,3 @@
+### Added
+
+- check to stop eth1 voting after electra and eth1 deposits stop