Update 3068

beacon-chain/core/blocks/withdrawals.go

@@ -8,6 +8,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
+	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/crypto/hash/htr"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
@@ -110,7 +111,11 @@ func ProcessWithdrawals(st state.BeaconState, withdrawals []*enginev1.Withdrawal
 		if err := st.SetNextWithdrawalIndex(withdrawals[len(withdrawals)-1].WithdrawalIndex + 1); err != nil {
 			return nil, errors.Wrap(err, "could not set next withdrawal index")
 		}
-		if err := st.SetLastWithdrawalValidatorIndex(withdrawals[len(withdrawals)-1].ValidatorIndex); err != nil {
+		nextValidatorIndex := withdrawals[len(withdrawals)-1].ValidatorIndex + 1
+		if nextValidatorIndex == types.ValidatorIndex(st.NumValidators()) {
+			nextValidatorIndex = 0
+		}
+		if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
 			return nil, errors.Wrap(err, "could not set latest withdrawal validator index")
 		}
 	}

beacon-chain/core/blocks/withdrawals_test.go

@@ -210,14 +210,14 @@ func TestProcessWithdrawals(t *testing.T) {
 
 	type args struct {
 		Name                         string
-		LastWithdrawalValidatorIndex types.ValidatorIndex
+		NextWithdrawalValidatorIndex types.ValidatorIndex
 		NextWithdrawalIndex          uint64
 		FullWithdrawalIndices        []types.ValidatorIndex
 		PartialWithdrawalIndices     []types.ValidatorIndex
 		Withdrawals                  []*enginev1.Withdrawal
 	}
 	type control struct {
-		LastWithdrawalValidatorIndex types.ValidatorIndex
+		NextWithdrawalValidatorIndex types.ValidatorIndex
 		NextWithdrawalIndex          uint64
 		ExpectedError                bool
 		Balances                     map[uint64]uint64
@@ -254,26 +254,26 @@ func TestProcessWithdrawals(t *testing.T) {
 		{
 			Args: args{
 				Name:                         "success no withdrawals",
-				LastWithdrawalValidatorIndex: 10,
+				NextWithdrawalValidatorIndex: 10,
 				NextWithdrawalIndex:          3,
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 10,
+				NextWithdrawalValidatorIndex: 10,
 				NextWithdrawalIndex:          3,
 			},
 		},
 		{
 			Args: args{
 				Name:                         "success one full withdrawal",
 				NextWithdrawalIndex:          3,
-				LastWithdrawalValidatorIndex: 5,
+				NextWithdrawalValidatorIndex: 5,
 				FullWithdrawalIndices:        []types.ValidatorIndex{1},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(1, 3),
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 1,
+				NextWithdrawalValidatorIndex: 2,
 				NextWithdrawalIndex:          4,
 				Balances:                     map[uint64]uint64{1: 0},
 			},
@@ -282,14 +282,14 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "success one partial withdrawal",
 				NextWithdrawalIndex:          21,
-				LastWithdrawalValidatorIndex: 37,
+				NextWithdrawalValidatorIndex: 37,
 				PartialWithdrawalIndices:     []types.ValidatorIndex{7},
 				Withdrawals: []*enginev1.Withdrawal{
 					partialWithdrawal(7, 21),
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 7,
+				NextWithdrawalValidatorIndex: 8,
 				NextWithdrawalIndex:          22,
 				Balances:                     map[uint64]uint64{7: maxEffectiveBalance},
 			},
@@ -298,15 +298,15 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "success many full withdrawals",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []types.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
 					fullWithdrawal(1, 25),
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 1,
+				NextWithdrawalValidatorIndex: 2,
 				NextWithdrawalIndex:          26,
 				Balances:                     map[uint64]uint64{7: 0, 19: 0, 28: 0, 1: 0},
 			},
@@ -315,15 +315,15 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "success many partial withdrawals",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				PartialWithdrawalIndices:     []types.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
 					partialWithdrawal(7, 22), partialWithdrawal(19, 23), partialWithdrawal(28, 24),
 					partialWithdrawal(1, 25),
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 1,
+				NextWithdrawalValidatorIndex: 2,
 				NextWithdrawalIndex:          26,
 				Balances: map[uint64]uint64{
 					7:  maxEffectiveBalance,
@@ -337,7 +337,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "success many withdrawals",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 12,
+				NextWithdrawalValidatorIndex: 12,
 				FullWithdrawalIndices:        []types.ValidatorIndex{7, 19, 28},
 				PartialWithdrawalIndices:     []types.ValidatorIndex{2, 1, 89, 15},
 				Withdrawals: []*enginev1.Withdrawal{
@@ -347,7 +347,7 @@ func TestProcessWithdrawals(t *testing.T) {
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 7,
+				NextWithdrawalValidatorIndex: 8,
 				NextWithdrawalIndex:          29,
 				Balances: map[uint64]uint64{
 					7: 0, 19: 0, 28: 0,
@@ -360,7 +360,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "success more than max fully withdrawals",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 0,
+				NextWithdrawalValidatorIndex: 0,
 				FullWithdrawalIndices:        []types.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(1, 22), fullWithdrawal(2, 23), fullWithdrawal(3, 24),
@@ -372,7 +372,7 @@ func TestProcessWithdrawals(t *testing.T) {
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 27,
+				NextWithdrawalValidatorIndex: 28,
 				NextWithdrawalIndex:          38,
 				Balances: map[uint64]uint64{
 					1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,
@@ -384,7 +384,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "success more than max partially withdrawals",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 0,
+				NextWithdrawalValidatorIndex: 0,
 				PartialWithdrawalIndices:     []types.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
 				Withdrawals: []*enginev1.Withdrawal{
 					partialWithdrawal(1, 22), partialWithdrawal(2, 23), partialWithdrawal(3, 24),
@@ -396,7 +396,7 @@ func TestProcessWithdrawals(t *testing.T) {
 				},
 			},
 			Control: control{
-				LastWithdrawalValidatorIndex: 27,
+				NextWithdrawalValidatorIndex: 28,
 				NextWithdrawalIndex:          38,
 				Balances: map[uint64]uint64{
 					1:  maxEffectiveBalance,
@@ -422,7 +422,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "failure wrong number of partial withdrawal",
 				NextWithdrawalIndex:          21,
-				LastWithdrawalValidatorIndex: 37,
+				NextWithdrawalValidatorIndex: 37,
 				PartialWithdrawalIndices:     []types.ValidatorIndex{7},
 				Withdrawals: []*enginev1.Withdrawal{
 					partialWithdrawal(7, 21), partialWithdrawal(9, 22),
@@ -436,7 +436,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "failure invalid withdrawal index",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []types.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 25),
@@ -451,7 +451,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "failure invalid validator index",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []types.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(27, 24),
@@ -466,7 +466,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "failure invalid withdrawal amount",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []types.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(7, 22), fullWithdrawal(19, 23), partialWithdrawal(28, 24),
@@ -481,7 +481,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "failure validator not fully withdrawable",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []types.ValidatorIndex{notWithdrawableIndex},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(notWithdrawableIndex, 22),
@@ -495,7 +495,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Args: args{
 				Name:                         "failure validator not partially withdrawable",
 				NextWithdrawalIndex:          22,
-				LastWithdrawalValidatorIndex: 4,
+				NextWithdrawalValidatorIndex: 4,
 				PartialWithdrawalIndices:     []types.ValidatorIndex{notPartiallyWithdrawable},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(notPartiallyWithdrawable, 22),
@@ -510,7 +510,7 @@ func TestProcessWithdrawals(t *testing.T) {
 	checkPostState := func(t *testing.T, expected control, st state.BeaconState) {
 		l, err := st.LastWithdrawalValidatorIndex()
 		require.NoError(t, err)
-		require.Equal(t, expected.LastWithdrawalValidatorIndex, l)
+		require.Equal(t, expected.NextWithdrawalValidatorIndex, l)
 
 		n, err := st.NextWithdrawalIndex()
 		require.NoError(t, err)
@@ -563,7 +563,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			require.NoError(t, err)
 			spb := &ethpb.BeaconStateCapella{
 				Slot:                         slot,
-				LastWithdrawalValidatorIndex: test.Args.LastWithdrawalValidatorIndex,
+				NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
 				NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
 			}
 			st, err := prepareValidators(spb, test.Args)

beacon-chain/core/capella/upgrade.go

@@ -89,7 +89,7 @@ func UpgradeToCapella(state state.BeaconState) (state.BeaconState, error) {
 			WithdrawalsRoot:  make([]byte, 32),
 		},
 		NextWithdrawalIndex:          0,
-		LastWithdrawalValidatorIndex: 0,
+		NextWithdrawalValidatorIndex: 0,
 	}
 
 	return state_native.InitializeFromProtoUnsafeCapella(s)

beacon-chain/state/interfaces.go

@@ -87,7 +87,7 @@ type WriteOnlyBeaconState interface {
 	AppendHistoricalRoots(root [32]byte) error
 	SetLatestExecutionPayloadHeader(payload interfaces.ExecutionData) error
 	SetNextWithdrawalIndex(i uint64) error
-	SetLastWithdrawalValidatorIndex(i types.ValidatorIndex) error
+	SetNextWithdrawalValidatorIndex(i types.ValidatorIndex) error
 }
 
 // ReadOnlyValidator defines a struct which only has read access to validator methods.

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

@@ -48,7 +48,7 @@ type BeaconState struct {
 	latestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader
 	latestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella
 	nextWithdrawalIndex                 uint64
-	lastWithdrawalValidatorIndex        eth2types.ValidatorIndex
+	nextWithdrawalValidatorIndex        eth2types.ValidatorIndex
 
 	lock                  sync.RWMutex
 	dirtyFields           map[nativetypes.FieldIndex]bool

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

@@ -125,7 +125,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			NextSyncCommittee:            b.nextSyncCommittee,
 			LatestExecutionPayloadHeader: b.latestExecutionPayloadHeaderCapella,
 			NextWithdrawalIndex:          b.nextWithdrawalIndex,
-			LastWithdrawalValidatorIndex: b.lastWithdrawalValidatorIndex,
+			NextWithdrawalValidatorIndex: b.nextWithdrawalValidatorIndex,
 		}
 	default:
 		return nil
@@ -251,7 +251,7 @@ func (b *BeaconState) ToProto() interface{} {
 			NextSyncCommittee:            b.nextSyncCommitteeVal(),
 			LatestExecutionPayloadHeader: b.latestExecutionPayloadHeaderCapellaVal(),
 			NextWithdrawalIndex:          b.nextWithdrawalIndex,
-			LastWithdrawalValidatorIndex: b.lastWithdrawalValidatorIndex,
+			NextWithdrawalValidatorIndex: b.nextWithdrawalValidatorIndex,
 		}
 	default:
 		return nil

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

@@ -34,7 +34,7 @@ func (b *BeaconState) LastWithdrawalValidatorIndex() (types.ValidatorIndex, erro
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.lastWithdrawalValidatorIndex, nil
+	return b.nextWithdrawalValidatorIndex, nil
 }
 
 // ExpectedWithdrawals returns the withdrawals that a proposer will need to pack in the next block
@@ -49,14 +49,13 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
 	defer b.lock.RUnlock()
 
 	withdrawals := make([]*enginev1.Withdrawal, 0, params.BeaconConfig().MaxWithdrawalsPerPayload)
-	validatorIndex := b.lastWithdrawalValidatorIndex
+	validatorIndex := b.nextWithdrawalValidatorIndex + 1
+	if uint64(validatorIndex) == uint64(len(b.validators)) {
+		validatorIndex = 0
+	}
 	withdrawalIndex := b.nextWithdrawalIndex
 	epoch := slots.ToEpoch(b.slot)
 	for range b.validators {
-		validatorIndex += 1
-		if uint64(validatorIndex) == uint64(len(b.validators)) {
-			validatorIndex = types.ValidatorIndex(0)
-		}
 		val := b.validators[validatorIndex]
 		balance := b.balances[validatorIndex]
 		if isFullyWithdrawableValidator(val, epoch) {
@@ -79,6 +78,10 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
 		if uint64(len(withdrawals)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
 			break
 		}
+		validatorIndex += 1
+		if uint64(validatorIndex) == uint64(len(b.validators)) {
+			validatorIndex = 0
+		}
 	}
 	return withdrawals, nil
 }

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

@@ -28,7 +28,7 @@ func TestNextWithdrawalIndex(t *testing.T) {
 
 func TestLastWithdrawalValidatorIndex(t *testing.T) {
 	t.Run("ok", func(t *testing.T) {
-		s := BeaconState{version: version.Capella, lastWithdrawalValidatorIndex: 123}
+		s := BeaconState{version: version.Capella, nextWithdrawalValidatorIndex: 123}
 		i, err := s.LastWithdrawalValidatorIndex()
 		require.NoError(t, err)
 		assert.Equal(t, types.ValidatorIndex(123), i)
@@ -136,7 +136,7 @@ func TestExpectedWithdrawals(t *testing.T) {
 			version:                      version.Capella,
 			validators:                   make([]*ethpb.Validator, 100),
 			balances:                     make([]uint64, 100),
-			lastWithdrawalValidatorIndex: 20,
+			nextWithdrawalValidatorIndex: 20,
 		}
 		for i := range s.validators {
 			s.balances[i] = params.BeaconConfig().MaxEffectiveBalance

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

@@ -253,8 +253,8 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 
 		// Next partial withdrawal validator index root.
 		nextPartialWithdrawalValidatorIndexRoot := make([]byte, 32)
-		binary.LittleEndian.PutUint64(nextPartialWithdrawalValidatorIndexRoot, uint64(state.lastWithdrawalValidatorIndex))
-		fieldRoots[nativetypes.LastWithdrawalValidatorIndex.RealPosition()] = nextPartialWithdrawalValidatorIndexRoot
+		binary.LittleEndian.PutUint64(nextPartialWithdrawalValidatorIndexRoot, uint64(state.nextWithdrawalValidatorIndex))
+		fieldRoots[nativetypes.NextWithdrawalValidatorIndex.RealPosition()] = nextPartialWithdrawalValidatorIndexRoot
 	}
 
 	return fieldRoots, nil

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

@@ -257,7 +257,7 @@ func TestComputeFieldRootsWithHasher_Capella(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetLatestExecutionPayloadHeader(wrappedHeader))
 	require.NoError(t, beaconState.SetNextWithdrawalIndex(123))
-	require.NoError(t, beaconState.SetLastWithdrawalValidatorIndex(123))
+	require.NoError(t, beaconState.SetNextWithdrawalValidatorIndex(123))
 
 	nativeState, ok := beaconState.(*statenative.BeaconState)
 	require.Equal(t, true, ok)

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

@@ -20,14 +20,14 @@ func (b *BeaconState) SetNextWithdrawalIndex(i uint64) error {
 
 // SetLastWithdrawalValidatorIndex sets the index of the validator which is
 // next in line for a partial withdrawal.
-func (b *BeaconState) SetLastWithdrawalValidatorIndex(i types.ValidatorIndex) error {
+func (b *BeaconState) SetNextWithdrawalValidatorIndex(i types.ValidatorIndex) error {
 	if b.version < version.Capella {
-		return errNotSupported("SetNextPartialWithdrawalValidatorIndex", b.version)
+		return errNotSupported("SetNextWithdrawalValidatorIndex", b.version)
 	}
 
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	b.lastWithdrawalValidatorIndex = i
+	b.nextWithdrawalValidatorIndex = i
 	return nil
 }

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

@@ -19,8 +19,8 @@ func TestSetNextWithdrawalIndex(t *testing.T) {
 func TestSetLastWithdrawalValidatorIndex(t *testing.T) {
 	s := BeaconState{
 		version:                      version.Capella,
-		lastWithdrawalValidatorIndex: 3,
+		nextWithdrawalValidatorIndex: 3,
 	}
-	require.NoError(t, s.SetLastWithdrawalValidatorIndex(5))
-	require.Equal(t, types.ValidatorIndex(5), s.lastWithdrawalValidatorIndex)
+	require.NoError(t, s.SetNextWithdrawalValidatorIndex(5))
+	require.Equal(t, types.ValidatorIndex(5), s.nextWithdrawalValidatorIndex)
 }