@kasey feedback

beacon-chain/blockchain/testing/mock.go

@@ -77,7 +77,6 @@ type ChainService struct {
 	DataColumns                 []blocks.VerifiedRODataColumn
 	TargetRoot                  [32]byte
 	MockHeadSlot                *primitives.Slot
-	DependentRootCB             func([32]byte, primitives.Epoch) ([32]byte, error)
 }
 
 func (s *ChainService) Ancestor(ctx context.Context, root []byte, slot primitives.Slot) ([]byte, error) {
@@ -759,10 +758,7 @@ func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) err
 }
 
 // DependentRootForEpoch mocks the same method in the chain service
-func (c *ChainService) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-	if c.DependentRootCB != nil {
-		return c.DependentRootCB(root, epoch)
-	}
+func (c *ChainService) DependentRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil
 }
 

beacon-chain/db/kv/archived_point.go

@@ -29,10 +29,13 @@ func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
 	_, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedRoot")
 	defer span.End()
 
-	var blockRoot []byte
+	blockRoot := make([]byte, 0, 32)
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(stateSlotIndicesBucket)
-		_, blockRoot = bkt.Cursor().Last()
+		_, br := bkt.Cursor().Last()
+		if len(br) > 0 {
+			copy(blockRoot, br)
+		}
 		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.
@@ -47,10 +50,13 @@ func (s *Store) ArchivedPointRoot(ctx context.Context, slot primitives.Slot) [32
 	_, span := trace.StartSpan(ctx, "BeaconDB.ArchivedPointRoot")
 	defer span.End()
 
-	var blockRoot []byte
+	blockRoot := make([]byte, 0, 32)
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(stateSlotIndicesBucket)
-		blockRoot = bucket.Get(bytesutil.SlotToBytesBigEndian(slot))
+		br := bucket.Get(bytesutil.SlotToBytesBigEndian(slot))
+		if len(br) > 0 {
+			copy(blockRoot, br)
+		}
 		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

@@ -809,14 +809,17 @@ func (s *Store) HighestRootsBelowSlot(ctx context.Context, slot primitives.Slot)
 func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.FeeRecipientByValidatorID")
 	defer span.End()
-	var addr []byte
+	addr := make([]byte, 0, 20)
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(feeRecipientBucket)
-		addr = bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
+		stored := bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
+		if len(stored) > 0 {
+			copy(addr, stored)
+		}
 		// 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.
-		if addr == nil {
+		if len(addr) == 0 {
 			bkt = tx.Bucket(registrationBucket)
 			enc := bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
 			if enc == nil {
@@ -826,7 +829,7 @@ func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id primitives.Val
 			if err := decode(ctx, enc, reg); err != nil {
 				return err
 			}
-			addr = reg.FeeRecipient
+			copy(addr, reg.FeeRecipient)
 		}
 		return nil
 	})

beacon-chain/db/kv/deposit_contract.go

@@ -14,10 +14,13 @@ import (
 func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
 	_, span := trace.StartSpan(ctx, "BeaconDB.DepositContractAddress")
 	defer span.End()
-	var addr []byte
+	addr := make([]byte, 0, 20)
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		chainInfo := tx.Bucket(chainMetadataBucket)
-		addr = chainInfo.Get(depositContractAddressKey)
+		stored := chainInfo.Get(depositContractAddressKey)
+		if len(stored) > 0 {
+			copy(addr, stored)
+		}
 		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,8 @@ 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, pubKey)
+		keyCopy := bytes.Clone(pubKey)
+		keys = append(keys, keyCopy)
 		return nil
 	}); err != nil {
 		return nil, err

beacon-chain/db/kv/state_diff.go

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

beacon-chain/db/kv/state_summary.go

@@ -2,6 +2,7 @@ package kv
 
 import (
 	"context"
+	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
@@ -47,7 +48,11 @@ 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 {
-		enc = tx.Bucket(stateSummaryBucket).Get(blockRoot[:])
+		rawEnc := tx.Bucket(stateSummaryBucket).Get(blockRoot[:])
+		if len(rawEnc) == 0 {
+			return nil
+		}
+		enc = slices.Clone(rawEnc)
 		return nil
 	}); err != nil {
 		return nil, err

beacon-chain/rpc/endpoints.go

@@ -329,16 +329,6 @@ func (s *Service) validatorEndpoints(
 			handler: server.GetProposerDuties,
 			methods: []string{http.MethodGet},
 		},
-		{
-			template: "/eth/v2/validator/duties/proposer/{epoch}",
-			name:     namespace + ".GetProposerDutiesV2",
-			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.GetProposerDutiesV2,
-			methods: []string{http.MethodGet},
-		},
 		{
 			template: "/eth/v1/validator/duties/sync/{epoch}",
 			name:     namespace + ".GetSyncCommitteeDuties",

beacon-chain/rpc/endpoints_test.go

@@ -93,7 +93,6 @@ func Test_endpoints(t *testing.T) {
 	validatorRoutes := map[string][]string{
 		"/eth/v1/validator/duties/attester/{epoch}":        {http.MethodPost},
 		"/eth/v1/validator/duties/proposer/{epoch}":        {http.MethodGet},
-		"/eth/v2/validator/duties/proposer/{epoch}":        {http.MethodGet},
 		"/eth/v1/validator/duties/sync/{epoch}":            {http.MethodPost},
 		"/eth/v3/validator/blocks/{slot}":                  {http.MethodGet},
 		"/eth/v1/validator/attestation_data":               {http.MethodGet},

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

@@ -982,29 +982,20 @@ func (s *Server) GetAttesterDuties(w http.ResponseWriter, r *http.Request) {
 	httputil.WriteJson(w, response)
 }
 
-// proposerDutiesInfo holds the computed proposer duties and associated metadata.
-type proposerDutiesInfo struct {
-	duties       []*structs.ProposerDuty
-	isOptimistic bool
-	lookupEpoch  primitives.Epoch // epoch used for state lookup (adjusted for lookahead)
-	dutiesEpoch  primitives.Epoch // actual epoch duties are for
-	st           state.BeaconState
-}
+// GetProposerDuties requests beacon node to provide all validators that are scheduled to propose a block in the given epoch.
+func (s *Server) GetProposerDuties(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "validator.GetProposerDuties")
+	defer span.End()
 
-// computeProposerDuties computes proposer duties for the given epoch. It handles sync checking,
-// epoch parsing/validation, next-epoch lookahead, state fetch, assignment computation, duty building,
-// sorting, and optimistic check. It writes errors directly to w and returns nil if an error occurred.
-func (s *Server) computeProposerDuties(ctx context.Context, w http.ResponseWriter, r *http.Request) *proposerDutiesInfo {
 	if shared.IsSyncing(ctx, w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
-		return nil
+		return
 	}
 
 	_, requestedEpochUint, ok := shared.UintFromRoute(w, r, "epoch")
 	if !ok {
-		return nil
+		return
 	}
 	requestedEpoch := primitives.Epoch(requestedEpochUint)
-	dutiesEpoch := requestedEpoch
 
 	cs := s.TimeFetcher.CurrentSlot()
 	currentEpoch := slots.ToEpoch(cs)
@@ -1016,7 +1007,7 @@ func (s *Server) computeProposerDuties(ctx context.Context, w http.ResponseWrite
 			fmt.Sprintf("Request epoch %d can not be greater than next epoch %d", requestedEpoch, currentEpoch+1),
 			http.StatusBadRequest,
 		)
-		return nil
+		return
 	} else if requestedEpoch == nextEpoch {
 		// If the request is for the next epoch, we use the current epoch's state to compute duties.
 		requestedEpoch = currentEpoch
@@ -1026,18 +1017,18 @@ func (s *Server) computeProposerDuties(ctx context.Context, w http.ResponseWrite
 	st, err := s.Stater.StateByEpoch(ctx, requestedEpoch)
 	if err != nil {
 		shared.WriteStateFetchError(w, err)
-		return nil
+		return
 	}
 
 	var assignments map[primitives.ValidatorIndex][]primitives.Slot
 	if nextEpochLookahead {
-		assignments, err = helpers.ProposerAssignments(ctx, st, dutiesEpoch)
+		assignments, err = helpers.ProposerAssignments(ctx, st, nextEpoch)
 	} else {
 		assignments, err = helpers.ProposerAssignments(ctx, st, requestedEpoch)
 	}
 	if err != nil {
 		httputil.HandleError(w, "Could not compute committee assignments: "+err.Error(), http.StatusInternalServerError)
-		return nil
+		return
 	}
 
 	duties := make([]*structs.ProposerDuty, 0)
@@ -1045,7 +1036,7 @@ func (s *Server) computeProposerDuties(ctx context.Context, w http.ResponseWrite
 		val, err := st.ValidatorAtIndexReadOnly(index)
 		if err != nil {
 			httputil.HandleError(w, fmt.Sprintf("Could not get validator at index %d: %v", index, err), http.StatusInternalServerError)
-			return nil
+			return
 		}
 		pubkey48 := val.PublicKey()
 		pubkey := pubkey48[:]
@@ -1058,103 +1049,35 @@ func (s *Server) computeProposerDuties(ctx context.Context, w http.ResponseWrite
 		}
 	}
 
-	if err = sortProposerDuties(duties); err != nil {
-		httputil.HandleError(w, "Could not sort proposer duties: "+err.Error(), http.StatusInternalServerError)
-		return nil
+	var dependentRoot []byte
+	if requestedEpoch == 0 {
+		r, err := s.BeaconDB.GenesisBlockRoot(ctx)
+		if err != nil {
+			httputil.HandleError(w, "Could not get genesis block root: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		dependentRoot = r[:]
+	} else {
+		dependentRoot, err = proposalDependentRoot(st, requestedEpoch)
+		if err != nil {
+			httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
 	}
-
 	isOptimistic, err := s.OptimisticModeFetcher.IsOptimistic(ctx)
 	if err != nil {
 		httputil.HandleError(w, "Could not check optimistic status: "+err.Error(), http.StatusInternalServerError)
-		return nil
-	}
-
-	return &proposerDutiesInfo{
-		duties:       duties,
-		isOptimistic: isOptimistic,
-		lookupEpoch:  requestedEpoch,
-		dutiesEpoch:  dutiesEpoch,
-		st:           st,
-	}
-}
-
-// GetProposerDuties requests beacon node to provide all validators that are scheduled to propose a block in the given epoch.
-func (s *Server) GetProposerDuties(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "validator.GetProposerDuties")
-	defer span.End()
-
-	info := s.computeProposerDuties(ctx, w, r)
-	if info == nil {
 		return
 	}
-
-	var dependentRoot []byte
-	if info.lookupEpoch == 0 {
-		root, err := s.BeaconDB.GenesisBlockRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not get genesis block root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		dependentRoot = root[:]
-	} else {
-		var err error
-		dependentRoot, err = proposalDependentRoot(info.st, info.lookupEpoch)
-		if err != nil {
-			httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
+	if err = sortProposerDuties(duties); err != nil {
+		httputil.HandleError(w, "Could not sort proposer duties: "+err.Error(), http.StatusInternalServerError)
+		return
 	}
 
 	resp := &structs.GetProposerDutiesResponse{
 		DependentRoot:       hexutil.Encode(dependentRoot),
-		Data:                info.duties,
-		ExecutionOptimistic: info.isOptimistic,
-	}
-	httputil.WriteJson(w, resp)
-}
-
-// GetProposerDutiesV2 requests beacon node to provide all validators that are scheduled to propose a block in the given epoch.
-// V2 computes a fork-aware dependent root: post-Fulu uses DependentRootForEpoch(headRoot, epoch-1) to account for
-// the deterministic proposer lookahead, while pre-Fulu uses DependentRootForEpoch(headRoot, epoch) matching v1 semantics.
-func (s *Server) GetProposerDutiesV2(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "validator.GetProposerDutiesV2")
-	defer span.End()
-
-	info := s.computeProposerDuties(ctx, w, r)
-	if info == nil {
-		return
-	}
-
-	var dependentRoot []byte
-	if info.dutiesEpoch == 0 {
-		root, err := s.BeaconDB.GenesisBlockRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not get genesis block root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		dependentRoot = root[:]
-	} else {
-		headRoot, err := s.HeadFetcher.HeadRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not get head root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		depEpoch := info.dutiesEpoch
-		if depEpoch >= params.BeaconConfig().FuluForkEpoch {
-			depEpoch = info.dutiesEpoch - 1
-		}
-		root, err := s.HeadFetcher.DependentRootForEpoch(bytesutil.ToBytes32(headRoot), depEpoch)
-		if err != nil {
-			httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		dependentRoot = root[:]
-	}
-
-	resp := &structs.GetProposerDutiesResponse{
-		DependentRoot:       hexutil.Encode(dependentRoot),
-		Data:                info.duties,
-		ExecutionOptimistic: info.isOptimistic,
+		Data:                duties,
+		ExecutionOptimistic: isOptimistic,
 	}
 	httputil.WriteJson(w, resp)
 }

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

@@ -2542,175 +2542,6 @@ func TestGetProposerDuties(t *testing.T) {
 	})
 }
 
-func TestGetProposerDutiesV2(t *testing.T) {
-	helpers.ClearCache()
-
-	genesis := util.NewBeaconBlock()
-	depChainStart := params.BeaconConfig().MinGenesisActiveValidatorCount
-	deposits, _, err := util.DeterministicDepositsAndKeys(depChainStart)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(deposits))
-	require.NoError(t, err)
-	genesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	db := dbutil.SetupDB(t)
-	require.NoError(t, db.SaveGenesisBlockRoot(t.Context(), genesisRoot))
-
-	t.Run("epoch 0 returns genesis block root", func(t *testing.T) {
-		bs, err := transition.GenesisBeaconState(t.Context(), deposits, 0, eth1Data)
-		require.NoError(t, err, "Could not set up genesis state")
-		require.NoError(t, bs.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-		chainSlot := primitives.Slot(0)
-		chain := &mockChain.ChainService{
-			State: bs, Root: genesisRoot[:], Slot: &chainSlot,
-		}
-		s := &Server{
-			Stater:                 &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{0: bs}},
-			HeadFetcher:            chain,
-			TimeFetcher:            chain,
-			OptimisticModeFetcher:  chain,
-			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			PayloadIDCache:         cache.NewPayloadIDCache(),
-			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v2/validator/duties/proposer/{epoch}", nil)
-		request.SetPathValue("epoch", "0")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetProposerDutiesV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetProposerDutiesResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, hexutil.Encode(genesisRoot[:]), resp.DependentRoot)
-		assert.Equal(t, 31, len(resp.Data))
-	})
-	t.Run("pre-fulu uses DependentRootForEpoch with dutiesEpoch", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig().Copy()
-		cfg.FuluForkEpoch = 100 // well beyond our test epoch
-		params.OverrideBeaconConfig(cfg)
-
-		bs, err := transition.GenesisBeaconState(t.Context(), deposits, 0, eth1Data)
-		require.NoError(t, err, "Could not set up genesis state")
-		require.NoError(t, bs.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-		chainSlot := primitives.Slot(0)
-		preFuluRoot := [32]byte{'p', 'r', 'e'}
-		var capturedEpoch primitives.Epoch
-		chain := &mockChain.ChainService{
-			State: bs, Root: genesisRoot[:], Slot: &chainSlot,
-			DependentRootCB: func(_ [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-				capturedEpoch = epoch
-				return preFuluRoot, nil
-			},
-		}
-		s := &Server{
-			Stater:                 &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{0: bs}},
-			HeadFetcher:            chain,
-			TimeFetcher:            chain,
-			OptimisticModeFetcher:  chain,
-			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			PayloadIDCache:         cache.NewPayloadIDCache(),
-			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
-		}
-
-		// Request epoch 1 (pre-Fulu since FuluForkEpoch=100).
-		// V2 pre-Fulu calls DependentRootForEpoch(headRoot, dutiesEpoch=1).
-		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v2/validator/duties/proposer/{epoch}", nil)
-		request.SetPathValue("epoch", "1")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetProposerDutiesV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetProposerDutiesResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, hexutil.Encode(preFuluRoot[:]), resp.DependentRoot)
-		assert.Equal(t, primitives.Epoch(1), capturedEpoch, "pre-Fulu should pass dutiesEpoch to DependentRootForEpoch")
-		assert.Equal(t, 32, len(resp.Data))
-	})
-	t.Run("post-fulu uses DependentRootForEpoch with dutiesEpoch-1", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig().Copy()
-		cfg.FuluForkEpoch = 0 // Fulu active from genesis
-		params.OverrideBeaconConfig(cfg)
-
-		bs, err := transition.GenesisBeaconState(t.Context(), deposits, 0, eth1Data)
-		require.NoError(t, err, "Could not set up genesis state")
-		require.NoError(t, bs.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-		chainSlot := primitives.Slot(0)
-		postFuluRoot := [32]byte{'p', 'o', 's', 't'}
-		var capturedEpoch primitives.Epoch
-		chain := &mockChain.ChainService{
-			State: bs, Root: genesisRoot[:], Slot: &chainSlot,
-			DependentRootCB: func(_ [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-				capturedEpoch = epoch
-				return postFuluRoot, nil
-			},
-		}
-		s := &Server{
-			Stater:                 &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{0: bs}},
-			HeadFetcher:            chain,
-			TimeFetcher:            chain,
-			OptimisticModeFetcher:  chain,
-			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			PayloadIDCache:         cache.NewPayloadIDCache(),
-			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
-		}
-
-		// Request epoch 1 (post-Fulu since FuluForkEpoch=0).
-		// V2 post-Fulu calls DependentRootForEpoch(headRoot, dutiesEpoch-1=0).
-		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v2/validator/duties/proposer/{epoch}", nil)
-		request.SetPathValue("epoch", "1")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetProposerDutiesV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetProposerDutiesResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, hexutil.Encode(postFuluRoot[:]), resp.DependentRoot)
-		assert.Equal(t, primitives.Epoch(0), capturedEpoch, "post-Fulu should pass dutiesEpoch-1 to DependentRootForEpoch")
-		assert.Equal(t, 32, len(resp.Data))
-	})
-	t.Run("next epoch lookahead", func(t *testing.T) {
-		bs, err := transition.GenesisBeaconState(t.Context(), deposits, 0, eth1Data)
-		require.NoError(t, err, "Could not set up genesis state")
-		require.NoError(t, bs.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-		chainSlot := primitives.Slot(0)
-		targetRoot := [32]byte{'n', 'e', 'x', 't'}
-		chain := &mockChain.ChainService{
-			State: bs, Root: genesisRoot[:], Slot: &chainSlot, TargetRoot: targetRoot,
-		}
-		s := &Server{
-			Stater:                 &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{0: bs}},
-			HeadFetcher:            chain,
-			TimeFetcher:            chain,
-			OptimisticModeFetcher:  chain,
-			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			PayloadIDCache:         cache.NewPayloadIDCache(),
-			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v2/validator/duties/proposer/{epoch}", nil)
-		request.SetPathValue("epoch", "1")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetProposerDutiesV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetProposerDutiesResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, 32, len(resp.Data))
-	})
-}
-
 func TestGetSyncCommitteeDuties(t *testing.T) {
 	helpers.ClearCache()
 	params.SetupTestConfigCleanup(t)

changelog/james-prysm_proposer-duties-v2.md

@@ -1,3 +0,0 @@
-### Added
-
-- /eth/v2/validator/duties/proposer/{epoch} implementation with updated dependent root info.