Continuous Staking WIP - Restake permissionless stakers by default

vms/platformvm/api/static_service.go

@@ -89,9 +89,11 @@ func (utxo UTXO) Less(other UTXO) bool {
 type Staker struct {
 	TxID      ids.ID      `json:"txID"`
 	StartTime json.Uint64 `json:"startTime"`
-	EndTime   json.Uint64 `json:"endTime"`
-	Weight    json.Uint64 `json:"weight"`
-	NodeID    ids.NodeID  `json:"nodeID"`
+	// TODO ABENEGIA: consider adding Duration here too, since
+	// endTime may be +infinity for continuous stakers
+	EndTime json.Uint64 `json:"endTime"`
+	Weight  json.Uint64 `json:"weight"`
+	NodeID  ids.NodeID  `json:"nodeID"`
 
 	// Deprecated: Use Weight instead
 	// TODO: remove [StakeAmount] after enough time for dependencies to update

vms/platformvm/blocks/executor/helpers_test.go

@@ -99,9 +99,10 @@ var (
 type stakerStatus uint
 
 type staker struct {
-	nodeID             ids.NodeID
-	rewardAddress      ids.ShortID
-	startTime, endTime time.Time
+	nodeID        ids.NodeID
+	rewardAddress ids.ShortID
+	startTime     time.Time
+	stakingPeriod time.Duration
 }
 
 type test struct {

vms/platformvm/blocks/executor/proposal_block_test.go

@@ -98,6 +98,7 @@ func TestApricotProposalBlockTimeVerification(t *testing.T) {
 		SubnetID:  utx.SubnetID(),
 		StartTime: utx.StartTime(),
 		EndTime:   chainTime,
+		NextTime:  chainTime,
 	})
 	currentStakersIt.EXPECT().Release()
 	onParentAccept.EXPECT().GetCurrentStakerIterator().Return(currentStakersIt, nil)
@@ -107,9 +108,11 @@ func TestApricotProposalBlockTimeVerification(t *testing.T) {
 		SubnetID:  utx.SubnetID(),
 		StartTime: utx.StartTime(),
 		EndTime:   chainTime,
+		NextTime:  chainTime,
 	}, nil)
 	onParentAccept.EXPECT().GetTx(addValTx.ID()).Return(addValTx, status.Committed, nil)
 	onParentAccept.EXPECT().GetCurrentSupply(constants.PrimaryNetworkID).Return(uint64(1000), nil).AnyTimes()
+	onParentAccept.EXPECT().GetRewardUTXOs(gomock.Any()).Return([]*avax.UTXO{}, nil).AnyTimes()
 	onParentAccept.EXPECT().GetDelegateeReward(constants.PrimaryNetworkID, utx.NodeID()).Return(uint64(0), nil).AnyTimes()
 	onParentAccept.EXPECT().GetRewardConfig(gomock.Any()).Return(env.config.RewardConfig, nil).AnyTimes()
 
@@ -150,7 +153,7 @@ func TestBanffProposalBlockTimeVerification(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	env := newEnvironment(t, ctrl, ContinuousStakingFork)
+	env := newEnvironment(t, ctrl, BanffFork)
 	defer func() {
 		require.NoError(shutdownEnvironment(env))
 	}()
@@ -234,6 +237,7 @@ func TestBanffProposalBlockTimeVerification(t *testing.T) {
 	currentStakersIt.EXPECT().Release().AnyTimes()
 	onParentAccept.EXPECT().GetCurrentStakerIterator().Return(currentStakersIt, nil).AnyTimes()
 
+	onParentAccept.EXPECT().GetRewardUTXOs(gomock.Any()).Return([]*avax.UTXO{}, nil).AnyTimes()
 	onParentAccept.EXPECT().GetDelegateeReward(constants.PrimaryNetworkID, unsignedNextStakerTx.NodeID()).Return(uint64(0), nil).AnyTimes()
 
 	pendingStakersIt := state.NewMockStakerIterator(ctrl)
@@ -401,54 +405,54 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) {
 		nodeID:        ids.NodeID(staker0RewardAddress),
 		rewardAddress: staker0RewardAddress,
 		startTime:     defaultGenesisTime,
-		endTime:       time.Time{}, // actual endTime depends on specific test
+		stakingPeriod: txs.StakerMaxDuration,
 	}
 
 	staker1RewardAddress := ids.GenerateTestShortID()
 	staker1 := staker{
 		nodeID:        ids.NodeID(staker1RewardAddress),
 		rewardAddress: staker1RewardAddress,
 		startTime:     defaultGenesisTime.Add(1 * time.Minute),
-		endTime:       defaultGenesisTime.Add(10 * defaultMinStakingDuration).Add(1 * time.Minute),
+		stakingPeriod: 10*defaultMinStakingDuration + time.Minute,
 	}
 
 	staker2RewardAddress := ids.ShortID{1}
 	staker2 := staker{
 		nodeID:        ids.NodeID(staker2RewardAddress),
 		rewardAddress: staker2RewardAddress,
 		startTime:     staker1.startTime.Add(1 * time.Minute),
-		endTime:       staker1.startTime.Add(1 * time.Minute).Add(defaultMinStakingDuration),
+		stakingPeriod: defaultMinStakingDuration + time.Minute,
 	}
 
 	staker3RewardAddress := ids.GenerateTestShortID()
 	staker3 := staker{
 		nodeID:        ids.NodeID(staker3RewardAddress),
 		rewardAddress: staker3RewardAddress,
 		startTime:     staker2.startTime.Add(1 * time.Minute),
-		endTime:       staker2.endTime.Add(1 * time.Minute),
+		stakingPeriod: staker2.stakingPeriod,
 	}
 
 	staker3Sub := staker{
 		nodeID:        staker3.nodeID,
 		rewardAddress: staker3.rewardAddress,
 		startTime:     staker3.startTime.Add(1 * time.Minute),
-		endTime:       staker3.endTime.Add(-1 * time.Minute),
+		stakingPeriod: staker3.stakingPeriod - time.Minute,
 	}
 
 	staker4RewardAddress := ids.GenerateTestShortID()
 	staker4 := staker{
 		nodeID:        ids.NodeID(staker4RewardAddress),
 		rewardAddress: staker4RewardAddress,
 		startTime:     staker3.startTime,
-		endTime:       staker3.endTime,
+		stakingPeriod: staker3.stakingPeriod,
 	}
 
 	staker5RewardAddress := ids.GenerateTestShortID()
 	staker5 := staker{
 		nodeID:        ids.NodeID(staker5RewardAddress),
 		rewardAddress: staker5RewardAddress,
-		startTime:     staker2.endTime,
-		endTime:       staker2.endTime.Add(defaultMinStakingDuration),
+		startTime:     staker2.startTime.Add(staker2.stakingPeriod),
+		stakingPeriod: defaultMinStakingDuration,
 	}
 
 	tests := []test{
@@ -564,7 +568,7 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.description, func(t *testing.T) {
 			require := require.New(t)
-			env := newEnvironment(t, nil, ContinuousStakingFork)
+			env := newEnvironment(t, nil, CortinaFork)
 			defer func() {
 				require.NoError(shutdownEnvironment(env))
 			}()
@@ -574,10 +578,12 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) {
 			env.config.Validators.Add(subnetID, validators.NewSet())
 
 			for _, staker := range test.stakers {
+				start := staker.startTime.Unix()
+				end := staker.startTime.Add(staker.stakingPeriod).Unix()
 				tx, err := env.txBuilder.NewAddValidatorTx(
 					env.config.MinValidatorStake,
-					uint64(staker.startTime.Unix()),
-					uint64(staker.endTime.Unix()),
+					uint64(start),
+					uint64(end),
 					staker.nodeID,
 					staker.rewardAddress,
 					reward.PercentDenominator,
@@ -598,10 +604,12 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) {
 			}
 
 			for _, subStaker := range test.subnetStakers {
+				start := subStaker.startTime.Unix()
+				end := subStaker.startTime.Add(subStaker.stakingPeriod).Unix()
 				tx, err := env.txBuilder.NewAddSubnetValidatorTx(
 					10, // Weight
-					uint64(subStaker.startTime.Unix()),
-					uint64(subStaker.endTime.Unix()),
+					uint64(start),
+					uint64(end),
 					subStaker.nodeID, // validator ID
 					subnetID,         // Subnet ID
 					[]*secp256k1.PrivateKey{preFundedKeys[0], preFundedKeys[1]},
@@ -625,11 +633,11 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) {
 
 				// add Staker0 (with the right end time) to state
 				// so to allow proposalBlk issuance
-				staker0.endTime = newTime
+				staker0.stakingPeriod = newTime.Sub(staker0.startTime)
 				addStaker0, err := env.txBuilder.NewAddValidatorTx(
 					10,
 					uint64(staker0.startTime.Unix()),
-					uint64(staker0.endTime.Unix()),
+					uint64(staker0.startTime.Add(staker0.stakingPeriod).Unix()),
 					staker0.nodeID,
 					staker0.rewardAddress,
 					reward.PercentDenominator,
@@ -712,7 +720,7 @@ func TestBanffProposalBlockUpdateStakers(t *testing.T) {
 
 func TestBanffProposalBlockRemoveSubnetValidator(t *testing.T) {
 	require := require.New(t)
-	env := newEnvironment(t, nil, ContinuousStakingFork)
+	env := newEnvironment(t, nil, CortinaFork)
 	defer func() {
 		require.NoError(shutdownEnvironment(env))
 	}()
@@ -853,7 +861,7 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) {
 	for _, tracked := range []bool{true, false} {
 		t.Run(fmt.Sprintf("tracked %t", tracked), func(ts *testing.T) {
 			require := require.New(t)
-			env := newEnvironment(t, nil, ContinuousStakingFork)
+			env := newEnvironment(t, nil, CortinaFork)
 			defer func() {
 				require.NoError(shutdownEnvironment(env))
 			}()
@@ -958,7 +966,7 @@ func TestBanffProposalBlockTrackedSubnet(t *testing.T) {
 
 func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) {
 	require := require.New(t)
-	env := newEnvironment(t, nil, ContinuousStakingFork)
+	env := newEnvironment(t, nil, CortinaFork)
 	defer func() {
 		require.NoError(shutdownEnvironment(env))
 	}()
@@ -1142,7 +1150,7 @@ func TestBanffProposalBlockDelegatorStakerWeight(t *testing.T) {
 
 func TestBanffProposalBlockDelegatorStakers(t *testing.T) {
 	require := require.New(t)
-	env := newEnvironment(t, nil, ContinuousStakingFork)
+	env := newEnvironment(t, nil, CortinaFork)
 	defer func() {
 		require.NoError(shutdownEnvironment(env))
 	}()

vms/platformvm/blocks/executor/standard_block_test.go

@@ -369,37 +369,37 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) {
 		nodeID:        ids.GenerateTestNodeID(),
 		rewardAddress: ids.GenerateTestShortID(),
 		startTime:     defaultGenesisTime.Add(1 * time.Minute),
-		endTime:       defaultGenesisTime.Add(10 * defaultMinStakingDuration).Add(1 * time.Minute),
+		stakingPeriod: 10*defaultMinStakingDuration + time.Minute,
 	}
 	staker2 := staker{
 		nodeID:        ids.GenerateTestNodeID(),
 		rewardAddress: ids.GenerateTestShortID(),
 		startTime:     staker1.startTime.Add(1 * time.Minute),
-		endTime:       staker1.startTime.Add(1 * time.Minute).Add(defaultMinStakingDuration),
+		stakingPeriod: defaultMinStakingDuration + time.Minute,
 	}
 	staker3 := staker{
 		nodeID:        ids.GenerateTestNodeID(),
 		rewardAddress: ids.GenerateTestShortID(),
 		startTime:     staker2.startTime.Add(1 * time.Minute),
-		endTime:       staker2.endTime.Add(1 * time.Minute),
+		stakingPeriod: staker2.stakingPeriod,
 	}
 	staker3Sub := staker{
 		nodeID:        staker3.nodeID,
 		rewardAddress: ids.GenerateTestShortID(),
 		startTime:     staker3.startTime.Add(1 * time.Minute),
-		endTime:       staker3.endTime.Add(-1 * time.Minute),
+		stakingPeriod: staker3.stakingPeriod - time.Minute,
 	}
 	staker4 := staker{
 		nodeID:        ids.GenerateTestNodeID(),
 		rewardAddress: ids.GenerateTestShortID(),
 		startTime:     staker3.startTime,
-		endTime:       staker3.endTime,
+		stakingPeriod: staker3.stakingPeriod,
 	}
 	staker5 := staker{
 		nodeID:        ids.GenerateTestNodeID(),
 		rewardAddress: ids.GenerateTestShortID(),
-		startTime:     staker2.endTime,
-		endTime:       staker2.endTime.Add(defaultMinStakingDuration),
+		startTime:     staker2.startTime.Add(staker2.stakingPeriod),
+		stakingPeriod: defaultMinStakingDuration,
 	}
 
 	tests := []test{
@@ -492,7 +492,7 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.description, func(t *testing.T) {
 			require := require.New(t)
-			env := newEnvironment(t, nil, ContinuousStakingFork)
+			env := newEnvironment(t, nil, CortinaFork)
 			defer func() {
 				require.NoError(shutdownEnvironment(env))
 			}()
@@ -502,10 +502,12 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) {
 			env.config.Validators.Add(subnetID, validators.NewSet())
 
 			for _, staker := range test.stakers {
+				start := staker.startTime
+				end := staker.startTime.Add(staker.stakingPeriod)
 				_, err := addPendingValidator(
 					env,
-					staker.startTime,
-					staker.endTime,
+					start,
+					end,
 					staker.nodeID,
 					staker.rewardAddress,
 					[]*secp256k1.PrivateKey{preFundedKeys[0]},
@@ -514,10 +516,12 @@ func TestBanffStandardBlockUpdateStakers(t *testing.T) {
 			}
 
 			for _, staker := range test.subnetStakers {
+				start := staker.startTime
+				end := staker.startTime.Add(staker.stakingPeriod)
 				tx, err := env.txBuilder.NewAddSubnetValidatorTx(
 					10, // Weight
-					uint64(staker.startTime.Unix()),
-					uint64(staker.endTime.Unix()),
+					uint64(start.Unix()),
+					uint64(end.Unix()),
 					staker.nodeID, // validator ID
 					subnetID,      // Subnet ID
 					[]*secp256k1.PrivateKey{preFundedKeys[0], preFundedKeys[1]},

vms/platformvm/metrics/tx_metrics.go

@@ -27,7 +27,8 @@ type txMetrics struct {
 	numRemoveSubnetValidatorTxs,
 	numTransformSubnetTxs,
 	numAddPermissionlessValidatorTxs,
-	numAddPermissionlessDelegatorTxs prometheus.Counter
+	numAddPermissionlessDelegatorTxs,
+	numStopStakerTxs prometheus.Counter
 }
 
 func newTxMetrics(
@@ -49,6 +50,7 @@ func newTxMetrics(
 		numTransformSubnetTxs:            newTxMetric(namespace, "transform_subnet", registerer, &errs),
 		numAddPermissionlessValidatorTxs: newTxMetric(namespace, "add_permissionless_validator", registerer, &errs),
 		numAddPermissionlessDelegatorTxs: newTxMetric(namespace, "add_permissionless_delegator", registerer, &errs),
+		numStopStakerTxs:                 newTxMetric(namespace, "stop_staker_tx", registerer, &errs),
 	}
 	return m, errs.Err
 }
@@ -132,3 +134,8 @@ func (m *txMetrics) AddPermissionlessDelegatorTx(*txs.AddPermissionlessDelegator
 	m.numAddPermissionlessDelegatorTxs.Inc()
 	return nil
 }
+
+func (m *txMetrics) StopStakerTx(*txs.StopStakerTx) error {
+	m.numStopStakerTxs.Inc()
+	return nil
+}

vms/platformvm/state/masked_iterator_test.go

@@ -233,7 +233,7 @@ func buildMaskedIterator(parentStakers []Staker, deletedIndexes []int, updatedIn
 		s := parentStakers[idx]
 
 		cpy := s
-		RotateStakerTimesInPlace(&cpy)
+		ShiftStakerAheadInPlace(&cpy)
 		updatedStakers[s.TxID] = &cpy
 	}