Drop Pending Stakers 5 - validated PostDurango StakerTxs

tests/e2e/p/interchain_workflow.go

@@ -95,13 +95,9 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL
 		nodeID, nodePOP, err := infoClient.GetNodeID(e2e.DefaultContext())
 		require.NoError(err)
 
+		// Adding a validator should not break interchain transfer.
+		endTime := time.Now().Add(30 * time.Second)
 		ginkgo.By("adding the new node as a validator", func() {
-			startTime := time.Now().Add(e2e.DefaultValidatorStartTimeDiff)
-			// Validation duration doesn't actually matter to this
-			// test - it is only ensuring that adding a validator
-			// doesn't break interchain transfer.
-			endTime := startTime.Add(30 * time.Second)
-
 			rewardKey, err := secp256k1.NewPrivateKey()
 			require.NoError(err)
 
@@ -114,7 +110,6 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL
 				&txs.SubnetValidator{
 					Validator: txs.Validator{
 						NodeID: nodeID,
-						Start:  uint64(startTime.Unix()),
 						End:    uint64(endTime.Unix()),
 						Wght:   weight,
 					},
@@ -136,21 +131,15 @@ var _ = e2e.DescribePChain("[Interchain Workflow]", ginkgo.Label(e2e.UsesCChainL
 			require.NoError(err)
 		})
 
+		// Adding a delegator should not break interchain transfer.
 		ginkgo.By("adding a delegator to the new node", func() {
-			startTime := time.Now().Add(e2e.DefaultValidatorStartTimeDiff)
-			// Delegation duration doesn't actually matter to this
-			// test - it is only ensuring that adding a delegator
-			// doesn't break interchain transfer.
-			endTime := startTime.Add(15 * time.Second)
-
 			rewardKey, err := secp256k1.NewPrivateKey()
 			require.NoError(err)
 
 			_, err = pWallet.IssueAddPermissionlessDelegatorTx(
 				&txs.SubnetValidator{
 					Validator: txs.Validator{
 						NodeID: nodeID,
-						Start:  uint64(startTime.Unix()),
 						End:    uint64(endTime.Unix()),
 						Wght:   weight,
 					},

tests/e2e/p/permissionless_subnets.go

@@ -134,14 +134,13 @@ var _ = e2e.DescribePChain("[Permissionless Subnets]", func() {
 				require.NoError(err)
 			})
 
-			validatorStartTime := time.Now().Add(time.Minute)
+			endTime := time.Now().Add(time.Minute)
 			ginkgo.By("add permissionless validator", func() {
 				_, err := pWallet.IssueAddPermissionlessValidatorTx(
 					&txs.SubnetValidator{
 						Validator: txs.Validator{
 							NodeID: validatorID,
-							Start:  uint64(validatorStartTime.Unix()),
-							End:    uint64(validatorStartTime.Add(5 * time.Second).Unix()),
+							End:    uint64(endTime.Unix()),
 							Wght:   25 * units.MegaAvax,
 						},
 						Subnet: subnetID,
@@ -156,14 +155,12 @@ var _ = e2e.DescribePChain("[Permissionless Subnets]", func() {
 				require.NoError(err)
 			})
 
-			delegatorStartTime := validatorStartTime
 			ginkgo.By("add permissionless delegator", func() {
 				_, err := pWallet.IssueAddPermissionlessDelegatorTx(
 					&txs.SubnetValidator{
 						Validator: txs.Validator{
 							NodeID: validatorID,
-							Start:  uint64(delegatorStartTime.Unix()),
-							End:    uint64(delegatorStartTime.Add(5 * time.Second).Unix()),
+							End:    uint64(endTime.Unix()),
 							Wght:   25 * units.MegaAvax,
 						},
 						Subnet: subnetID,

tests/e2e/p/staking_rewards.go

@@ -31,8 +31,8 @@ import (
 )
 
 const (
-	delegationPeriod = 15 * time.Second
-	validationPeriod = 30 * time.Second
+	targetDelegationPeriod = 15 * time.Second
+	targetValidationPeriod = 30 * time.Second
 )
 
 var _ = ginkgo.Describe("[Staking Rewards]", func() {
@@ -58,6 +58,16 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 		ginkgo.By("waiting until beta node is healthy")
 		e2e.WaitForHealthy(betaNode)
 
+		ginkgo.By("retrieving alpha node id and pop")
+		alphaInfoClient := info.NewClient(alphaNode.URI)
+		alphaNodeID, alphaPOP, err := alphaInfoClient.GetNodeID(e2e.DefaultContext())
+		require.NoError(err)
+
+		ginkgo.By("retrieving beta node id and pop")
+		betaInfoClient := info.NewClient(betaNode.URI)
+		betaNodeID, betaPOP, err := betaInfoClient.GetNodeID(e2e.DefaultContext())
+		require.NoError(err)
+
 		ginkgo.By("generating reward keys")
 
 		alphaValidationRewardKey, err := secp256k1.NewPrivateKey()
@@ -89,43 +99,34 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 		keychain := secp256k1fx.NewKeychain(rewardKeys...)
 		fundedKey := e2e.Env.AllocatePreFundedKey()
 		keychain.Add(fundedKey)
-		nodeURI := e2e.Env.GetRandomNodeURI()
+		nodeURI := tmpnet.NodeURI{
+			NodeID: alphaNodeID,
+			URI:    alphaNode.URI,
+		}
 		baseWallet := e2e.NewWallet(keychain, nodeURI)
 		pWallet := baseWallet.P()
 
-		ginkgo.By("retrieving alpha node id and pop")
-		alphaInfoClient := info.NewClient(alphaNode.URI)
-		alphaNodeID, alphaPOP, err := alphaInfoClient.GetNodeID(e2e.DefaultContext())
-		require.NoError(err)
-
-		ginkgo.By("retrieving beta node id and pop")
-		betaInfoClient := info.NewClient(betaNode.URI)
-		betaNodeID, betaPOP, err := betaInfoClient.GetNodeID(e2e.DefaultContext())
-		require.NoError(err)
-
-		pvmClient := platformvm.NewClient(alphaNode.URI)
-
 		const (
 			delegationPercent = 0.10 // 10%
 			delegationShare   = reward.PercentDenominator * delegationPercent
 			weight            = 2_000 * units.Avax
 		)
 
+		pvmClient := platformvm.NewClient(alphaNode.URI)
+
 		ginkgo.By("retrieving supply before inserting validators")
 		supplyAtValidatorsStart, _, err := pvmClient.GetCurrentSupply(e2e.DefaultContext(), constants.PrimaryNetworkID)
 		require.NoError(err)
 
-		alphaValidatorStartTime := time.Now().Add(e2e.DefaultValidatorStartTimeDiff)
-		alphaValidatorEndTime := alphaValidatorStartTime.Add(validationPeriod)
-		tests.Outf("alpha node validation period starting at: %v\n", alphaValidatorStartTime)
+		alphaValidatorsEndTime := time.Now().Add(targetValidationPeriod)
+		tests.Outf("alpha node validation period ending at: %v\n", alphaValidatorsEndTime)
 
 		ginkgo.By("adding alpha node as a validator", func() {
 			_, err := pWallet.IssueAddPermissionlessValidatorTx(
 				&txs.SubnetValidator{
 					Validator: txs.Validator{
 						NodeID: alphaNodeID,
-						Start:  uint64(alphaValidatorStartTime.Unix()),
-						End:    uint64(alphaValidatorEndTime.Unix()),
+						End:    uint64(alphaValidatorsEndTime.Unix()),
 						Wght:   weight,
 					},
 					Subnet: constants.PrimaryNetworkID,
@@ -146,16 +147,14 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 			require.NoError(err)
 		})
 
-		betaValidatorStartTime := time.Now().Add(e2e.DefaultValidatorStartTimeDiff)
-		betaValidatorEndTime := betaValidatorStartTime.Add(validationPeriod)
-		tests.Outf("beta node validation period starting at: %v\n", betaValidatorStartTime)
+		betaValidatorEndTime := time.Now().Add(targetValidationPeriod)
+		tests.Outf("beta node validation period ending at: %v\n", betaValidatorEndTime)
 
 		ginkgo.By("adding beta node as a validator", func() {
 			_, err := pWallet.IssueAddPermissionlessValidatorTx(
 				&txs.SubnetValidator{
 					Validator: txs.Validator{
 						NodeID: betaNodeID,
-						Start:  uint64(betaValidatorStartTime.Unix()),
 						End:    uint64(betaValidatorEndTime.Unix()),
 						Wght:   weight,
 					},
@@ -181,16 +180,15 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 		supplyAtDelegatorsStart, _, err := pvmClient.GetCurrentSupply(e2e.DefaultContext(), constants.PrimaryNetworkID)
 		require.NoError(err)
 
-		gammaDelegatorStartTime := time.Now().Add(e2e.DefaultValidatorStartTimeDiff)
-		tests.Outf("gamma delegation period starting at: %v\n", gammaDelegatorStartTime)
+		gammaDelegatorEndTime := time.Now().Add(targetDelegationPeriod)
+		tests.Outf("gamma delegation period ending at: %v\n", gammaDelegatorEndTime)
 
 		ginkgo.By("adding gamma as delegator to the alpha node", func() {
 			_, err := pWallet.IssueAddPermissionlessDelegatorTx(
 				&txs.SubnetValidator{
 					Validator: txs.Validator{
 						NodeID: alphaNodeID,
-						Start:  uint64(gammaDelegatorStartTime.Unix()),
-						End:    uint64(gammaDelegatorStartTime.Add(delegationPeriod).Unix()),
+						End:    uint64(gammaDelegatorEndTime.Unix()),
 						Wght:   weight,
 					},
 					Subnet: constants.PrimaryNetworkID,
@@ -205,16 +203,15 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 			require.NoError(err)
 		})
 
-		deltaDelegatorStartTime := time.Now().Add(e2e.DefaultValidatorStartTimeDiff)
-		tests.Outf("delta delegation period starting at: %v\n", deltaDelegatorStartTime)
+		deltaDelegatorEndTime := time.Now().Add(targetDelegationPeriod)
+		tests.Outf("delta delegation period ending at: %v\n", deltaDelegatorEndTime)
 
 		ginkgo.By("adding delta as delegator to the beta node", func() {
 			_, err := pWallet.IssueAddPermissionlessDelegatorTx(
 				&txs.SubnetValidator{
 					Validator: txs.Validator{
 						NodeID: betaNodeID,
-						Start:  uint64(deltaDelegatorStartTime.Unix()),
-						End:    uint64(deltaDelegatorStartTime.Add(delegationPeriod).Unix()),
+						End:    uint64(deltaDelegatorEndTime.Unix()),
 						Wght:   weight,
 					},
 					Subnet: constants.PrimaryNetworkID,
@@ -232,6 +229,14 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 		ginkgo.By("stopping beta node to prevent it and its delegator from receiving a validation reward")
 		require.NoError(betaNode.Stop())
 
+		ginkgo.By("retrieving staking periods from the chain")
+		data, err := pvmClient.GetCurrentValidators(e2e.DefaultContext(), constants.PlatformChainID, []ids.NodeID{alphaNodeID})
+		require.NoError(err)
+		require.Len(data, 1)
+		actualAlphaValidationPeriod := time.Duration(data[0].EndTime-data[0].StartTime) * time.Second
+		delegatorData := data[0].Delegators[0]
+		actualGammaDelegationPeriod := time.Duration(delegatorData.EndTime-delegatorData.StartTime) * time.Second
+
 		ginkgo.By("waiting until all validation periods are over")
 		// The beta validator was the last added and so has the latest end time. The
 		// delegation periods are shorter than the validation periods.
@@ -279,8 +284,8 @@ var _ = ginkgo.Describe("[Staking Rewards]", func() {
 
 		ginkgo.By("determining expected validation and delegation rewards")
 		calculator := reward.NewCalculator(rewardConfig)
-		expectedValidationReward := calculator.Calculate(validationPeriod, weight, supplyAtValidatorsStart)
-		potentialDelegationReward := calculator.Calculate(delegationPeriod, weight, supplyAtDelegatorsStart)
+		expectedValidationReward := calculator.Calculate(actualAlphaValidationPeriod, weight, supplyAtValidatorsStart)
+		potentialDelegationReward := calculator.Calculate(actualGammaDelegationPeriod, weight, supplyAtDelegatorsStart)
 		expectedDelegationFee, expectedDelegatorReward := reward.Split(potentialDelegationReward, delegationShare)
 
 		ginkgo.By("checking expected rewards against actual rewards")

tests/e2e/p/workflow.go

@@ -68,9 +68,6 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 				require.NoError(err)
 				require.GreaterOrEqual(pBalance, minBalance)
 			})
-			// create validator data
-			validatorStartTimeDiff := 30 * time.Second
-			vdrStartTime := time.Now().Add(validatorStartTimeDiff)
 
 			// Use a random node ID to ensure that repeated test runs
 			// will succeed against a network that persists across runs.
@@ -79,8 +76,7 @@ var _ = e2e.DescribePChain("[Workflow]", func() {
 
 			vdr := &txs.Validator{
 				NodeID: validatorID,
-				Start:  uint64(vdrStartTime.Unix()),
-				End:    uint64(vdrStartTime.Add(72 * time.Hour).Unix()),
+				End:    uint64(time.Now().Add(72 * time.Hour).Unix()),
 				Wght:   minValStake,
 			}
 			rewardOwner := &secp256k1fx.OutputOwners{

tests/fixture/e2e/helpers.go

@@ -23,7 +23,6 @@ import (
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/tests"
 	"github.com/ava-labs/avalanchego/tests/fixture/tmpnet"
-	"github.com/ava-labs/avalanchego/vms/platformvm/txs/executor"
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 	"github.com/ava-labs/avalanchego/wallet/subnet/primary"
 	"github.com/ava-labs/avalanchego/wallet/subnet/primary/common"
@@ -44,11 +43,6 @@ const (
 	// development.
 	SkipBootstrapChecksEnvName = "E2E_SKIP_BOOTSTRAP_CHECKS"
 
-	// Validator start time must be a minimum of SyncBound from the
-	// current time for validator addition to succeed, and adding 20
-	// seconds provides a buffer in case of any delay in processing.
-	DefaultValidatorStartTimeDiff = executor.SyncBound + 20*time.Second
-
 	DefaultGasLimit = uint64(21000) // Standard gas limit
 
 	// An empty string prompts the use of the default path which ensures a