Drop explicit calls to chain.GetTx from txs execution paths

vms/platformvm/block/executor/proposal_block_test.go

@@ -96,6 +96,7 @@ func TestApricotProposalBlockTimeVerification(t *testing.T) {
 		StartTime: utx.StartTime(),
 		NextTime:  chainTime,
 		EndTime:   chainTime,
+		Priority:  utx.CurrentPriority(),
 	}).Times(2)
 	currentStakersIt.EXPECT().Release()
 	onParentAccept.EXPECT().GetCurrentStakerIterator().Return(currentStakersIt, nil)

vms/platformvm/state/diff.go

@@ -194,6 +194,31 @@ func (d *diff) GetCurrentStakerIterator() (StakerIterator, error) {
 	return d.currentStakerDiffs.GetStakerIterator(parentIterator), nil
 }
 
+func (d *diff) GetStakerColdAttributes(stakerID ids.ID) (*StakerColdAttributes, error) {
+	stakerTx, _, err := d.GetTx(stakerID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get next staker %s: %w", stakerID, err)
+	}
+	switch uStakerTx := stakerTx.Unsigned.(type) {
+	case txs.ValidatorTx:
+		return &StakerColdAttributes{
+			Stake:                  uStakerTx.Stake(),
+			Outputs:                uStakerTx.Outputs(),
+			Shares:                 uStakerTx.Shares(),
+			ValidationRewardsOwner: uStakerTx.ValidationRewardsOwner(),
+			DelegationRewardsOwner: uStakerTx.DelegationRewardsOwner(),
+		}, nil
+	case txs.DelegatorTx:
+		return &StakerColdAttributes{
+			Stake:        uStakerTx.Stake(),
+			Outputs:      uStakerTx.Outputs(),
+			RewardsOwner: uStakerTx.RewardsOwner(),
+		}, nil
+	default:
+		return nil, fmt.Errorf("unexpected stakerTx type %T", uStakerTx)
+	}
+}
+
 func (d *diff) GetPendingValidator(subnetID ids.ID, nodeID ids.NodeID) (*Staker, error) {
 	// If the validator was modified in this diff, return the modified
 	// validator.

vms/platformvm/state/staker.go

@@ -11,6 +11,8 @@ import (
 
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+	"github.com/ava-labs/avalanchego/vms/components/avax"
+	"github.com/ava-labs/avalanchego/vms/platformvm/fx"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
 )
 
@@ -121,3 +123,23 @@ func NewPendingStaker(txID ids.ID, staker txs.Staker) (*Staker, error) {
 		Priority:  staker.PendingPriority(),
 	}, nil
 }
+
+// While Staker object contains a staker's hot attributes, likely to be used pretty often
+// StakerColdAttributes contains a staker's cold attributes, rarely used, mostly when rewarding it.
+// Note that both Staker and StakerAttribute content comes from the stakerTx creating the staker.
+// In state.State we do have StakerMetadata information as well, which contains data about the stakers
+// that are generated during staker's activity (mostly uptimes)
+// TODO: consider moving delegatees reward here, out of StakersMetadata.
+type StakerColdAttributes struct {
+	// common attributes
+	Stake   []*avax.TransferableOutput
+	Outputs []*avax.TransferableOutput
+
+	// validators specific attributes
+	Shares                 uint32
+	ValidationRewardsOwner fx.Owner
+	DelegationRewardsOwner fx.Owner
+
+	// delegators specific attributes
+	RewardsOwner fx.Owner
+}

vms/platformvm/state/state.go

@@ -118,6 +118,8 @@ type Chain interface {
 
 	AddChain(createChainTx *txs.Tx)
 
+	GetStakerColdAttributes(stakerID ids.ID) (*StakerColdAttributes, error)
+
 	GetTx(txID ids.ID) (*txs.Tx, status.Status, error)
 	AddTx(tx *txs.Tx, status status.Status)
 }
@@ -733,6 +735,31 @@ func (s *state) GetCurrentStakerIterator() (StakerIterator, error) {
 	return s.currentStakers.GetStakerIterator(), nil
 }
 
+func (s *state) GetStakerColdAttributes(stakerID ids.ID) (*StakerColdAttributes, error) {
+	stakerTx, _, err := s.GetTx(stakerID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get next staker %s: %w", stakerID, err)
+	}
+	switch uStakerTx := stakerTx.Unsigned.(type) {
+	case txs.ValidatorTx:
+		return &StakerColdAttributes{
+			Stake:                  uStakerTx.Stake(),
+			Outputs:                uStakerTx.Outputs(),
+			Shares:                 uStakerTx.Shares(),
+			ValidationRewardsOwner: uStakerTx.ValidationRewardsOwner(),
+			DelegationRewardsOwner: uStakerTx.DelegationRewardsOwner(),
+		}, nil
+	case txs.DelegatorTx:
+		return &StakerColdAttributes{
+			Stake:        uStakerTx.Stake(),
+			Outputs:      uStakerTx.Outputs(),
+			RewardsOwner: uStakerTx.RewardsOwner(),
+		}, nil
+	default:
+		return nil, fmt.Errorf("unexpected stakerTx type %T", uStakerTx)
+	}
+}
+
 func (s *state) GetPendingValidator(subnetID ids.ID, nodeID ids.NodeID) (*Staker, error) {
 	return s.pendingStakers.GetValidator(subnetID, nodeID)
 }

vms/platformvm/txs/executor/proposal_tx_executor.go

@@ -363,36 +363,36 @@ func (e *ProposalTxExecutor) RewardValidatorTx(tx *txs.RewardValidatorTx) error
 		return err
 	}
 
-	stakerTx, _, err := e.OnCommitState.GetTx(stakerToReward.TxID)
+	stakerAttributes, err := e.OnCommitState.GetStakerColdAttributes(stakerToReward.TxID)
 	if err != nil {
-		return fmt.Errorf("failed to get next removed staker tx: %w", err)
+		return fmt.Errorf("failed to get attributes for staker %d: %w", stakerToReward.TxID, err)
 	}
 
-	// Invariant: A [txs.DelegatorTx] does not also implement the
-	//            [txs.ValidatorTx] interface.
-	switch uStakerTx := stakerTx.Unsigned.(type) {
-	case txs.ValidatorTx:
-		if err := e.rewardValidatorTx(uStakerTx, stakerToReward); err != nil {
+	switch {
+	case stakerToReward.Priority.IsPermissionedValidator():
+		// Invariant: Permissioned stakers are removed by the advancement of
+		//            time and the current chain timestamp is == this staker's
+		//            EndTime. This means only permissionless stakers should be
+		//            left in the staker set.
+		return ErrShouldBePermissionlessStaker
+	case stakerToReward.Priority.IsCurrentValidator():
+		if err := e.rewardValidatorTx(stakerToReward, stakerAttributes); err != nil {
 			return err
 		}
 
 		// Handle staker lifecycle.
 		e.OnCommitState.DeleteCurrentValidator(stakerToReward)
 		e.OnAbortState.DeleteCurrentValidator(stakerToReward)
-	case txs.DelegatorTx:
-		if err := e.rewardDelegatorTx(uStakerTx, stakerToReward); err != nil {
+	case stakerToReward.Priority.IsCurrentDelegator():
+		if err := e.rewardDelegatorTx(stakerToReward, stakerAttributes); err != nil {
 			return err
 		}
 
 		// Handle staker lifecycle.
 		e.OnCommitState.DeleteCurrentDelegator(stakerToReward)
 		e.OnAbortState.DeleteCurrentDelegator(stakerToReward)
 	default:
-		// Invariant: Permissioned stakers are removed by the advancement of
-		//            time and the current chain timestamp is == this staker's
-		//            EndTime. This means only permissionless stakers should be
-		//            left in the staker set.
-		return ErrShouldBePermissionlessStaker
+		return errors.New("unexpected staker type")
 	}
 
 	// If the reward is aborted, then the current supply should be decreased.
@@ -411,11 +411,11 @@ func (e *ProposalTxExecutor) RewardValidatorTx(tx *txs.RewardValidatorTx) error
 	return err
 }
 
-func (e *ProposalTxExecutor) rewardValidatorTx(uValidatorTx txs.ValidatorTx, validator *state.Staker) error {
+func (e *ProposalTxExecutor) rewardValidatorTx(validator *state.Staker, valAttributes *state.StakerColdAttributes) error {
 	var (
 		txID    = validator.TxID
-		stake   = uValidatorTx.Stake()
-		outputs = uValidatorTx.Outputs()
+		stake   = valAttributes.Stake
+		outputs = valAttributes.Outputs
 		// Invariant: The staked asset must be equal to the reward asset.
 		stakeAsset = stake[0].Asset
 	)
@@ -440,7 +440,7 @@ func (e *ProposalTxExecutor) rewardValidatorTx(uValidatorTx txs.ValidatorTx, val
 	// Provide the reward here
 	reward := validator.PotentialReward
 	if reward > 0 {
-		validationRewardsOwner := uValidatorTx.ValidationRewardsOwner()
+		validationRewardsOwner := valAttributes.ValidationRewardsOwner
 		outIntf, err := e.Fx.CreateOutput(reward, validationRewardsOwner)
 		if err != nil {
 			return fmt.Errorf("failed to create output: %w", err)
@@ -477,7 +477,7 @@ func (e *ProposalTxExecutor) rewardValidatorTx(uValidatorTx txs.ValidatorTx, val
 		return nil
 	}
 
-	delegationRewardsOwner := uValidatorTx.DelegationRewardsOwner()
+	delegationRewardsOwner := valAttributes.DelegationRewardsOwner
 	outIntf, err := e.Fx.CreateOutput(delegateeReward, delegationRewardsOwner)
 	if err != nil {
 		return fmt.Errorf("failed to create output: %w", err)
@@ -513,11 +513,11 @@ func (e *ProposalTxExecutor) rewardValidatorTx(uValidatorTx txs.ValidatorTx, val
 	return nil
 }
 
-func (e *ProposalTxExecutor) rewardDelegatorTx(uDelegatorTx txs.DelegatorTx, delegator *state.Staker) error {
+func (e *ProposalTxExecutor) rewardDelegatorTx(delegator *state.Staker, delAttributes *state.StakerColdAttributes) error {
 	var (
 		txID    = delegator.TxID
-		stake   = uDelegatorTx.Stake()
-		outputs = uDelegatorTx.Outputs()
+		stake   = delAttributes.Stake
+		outputs = delAttributes.Outputs
 		// Invariant: The staked asset must be equal to the reward asset.
 		stakeAsset = stake[0].Asset
 	)
@@ -544,29 +544,20 @@ func (e *ProposalTxExecutor) rewardDelegatorTx(uDelegatorTx txs.DelegatorTx, del
 		return fmt.Errorf("failed to get whether %s is a validator: %w", delegator.NodeID, err)
 	}
 
-	vdrTxIntf, _, err := e.OnCommitState.GetTx(validator.TxID)
+	valAttributes, err := e.OnCommitState.GetStakerColdAttributes(validator.TxID)
 	if err != nil {
 		return fmt.Errorf("failed to get whether %s is a validator: %w", delegator.NodeID, err)
 	}
 
-	// Invariant: Delegators must only be able to reference validator
-	//            transactions that implement [txs.ValidatorTx]. All
-	//            validator transactions implement this interface except the
-	//            AddSubnetValidatorTx.
-	vdrTx, ok := vdrTxIntf.Unsigned.(txs.ValidatorTx)
-	if !ok {
-		return ErrWrongTxType
-	}
-
 	// Calculate split of reward between delegator/delegatee
-	delegateeReward, delegatorReward := reward.Split(delegator.PotentialReward, vdrTx.Shares())
+	delegateeReward, delegatorReward := reward.Split(delegator.PotentialReward, valAttributes.Shares)
 
 	utxosOffset := 0
 
 	// Reward the delegator here
 	reward := delegatorReward
 	if reward > 0 {
-		rewardsOwner := uDelegatorTx.RewardsOwner()
+		rewardsOwner := delAttributes.RewardsOwner
 		outIntf, err := e.Fx.CreateOutput(reward, rewardsOwner)
 		if err != nil {
 			return fmt.Errorf("failed to create output: %w", err)
@@ -622,7 +613,7 @@ func (e *ProposalTxExecutor) rewardDelegatorTx(uDelegatorTx txs.DelegatorTx, del
 	} else {
 		// For any validators who started prior to [CortinaTime], we issue the
 		// [delegateeReward] immediately.
-		delegationRewardsOwner := vdrTx.DelegationRewardsOwner()
+		delegationRewardsOwner := valAttributes.DelegationRewardsOwner
 		outIntf, err := e.Fx.CreateOutput(delegateeReward, delegationRewardsOwner)
 		if err != nil {
 			return fmt.Errorf("failed to create output: %w", err)