Working version

1. Return all Validators directly, skip most of the current mechanisms and check (`BlockValidatorUpdates`)
2. Do not actually transfer coin for Validators created via SetComputeValidators
3. Bulk of the logic in SetComputeValidators:
Map all of the current validators and computeResults via PubKey.
- Modify ones that need to be modified
- Set to 0 ones to be removed
- Create new ones

Author: patimen

x/staking/keeper/abci.go

@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"context"
+	"cosmossdk.io/math"
 
 	abci "github.com/cometbft/cometbft/abci/types"
 
@@ -19,5 +20,15 @@ func (k *Keeper) BeginBlocker(ctx context.Context) error {
 // EndBlocker called at every block, update validator set
 func (k *Keeper) EndBlocker(ctx context.Context) ([]abci.ValidatorUpdate, error) {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, telemetry.Now(), telemetry.MetricKeyEndBlocker)
-	return k.BlockValidatorUpdates(ctx)
+	allValidators, err := k.GetAllValidators(ctx)
+	if err != nil {
+		return nil, err
+	}
+	updates := make([]abci.ValidatorUpdate, 0, len(allValidators))
+	for _, validator := range allValidators {
+		update := validator.ABCIValidatorUpdate(math.NewInt(1))
+		updates = append(updates, update)
+		k.Logger(ctx).Info("UpdateValidator:", "pubKey", update.PubKey, "power", update.Power)
+	}
+	return updates, nil
 }

x/staking/keeper/compute.go

@@ -0,0 +1,134 @@
+package keeper
+
+import (
+	"context"
+	"cosmossdk.io/math"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+type ComputeResult struct {
+	Power           int64
+	ValidatorPubKey cryptotypes.PubKey
+	OperatorAddress string
+}
+
+func (k Keeper) SetComputeValidators(ctx context.Context, computeResults []ComputeResult) ([]types.Validator, error) {
+	server := NewMsgServerImpl(&k)
+	logger := k.Logger(ctx)
+	resultsMap := make(map[string]ComputeResult)
+	for _, result := range computeResults {
+		resultsMap[result.ValidatorPubKey.String()] = result
+	}
+
+	currentValidators, err := k.GetAllValidators(ctx)
+	if err != nil {
+		logger.Error("error getting current validators", "error", err.Error())
+		return nil, err
+	}
+
+	validatorsAlreadyExisting := make(map[string]bool)
+	for _, validator := range currentValidators {
+		conPubKey, err := validator.ConsPubKey()
+		if err != nil {
+			logger.Error("Error getting cons pubkey", "error", err.Error())
+			return nil, err
+		}
+		validatorsAlreadyExisting[conPubKey.String()] = true
+	}
+
+	// Handle validators already in
+	for _, validator := range currentValidators {
+		conPubKey, err := validator.ConsPubKey()
+		if err != nil {
+			logger.Error("Error getting cons pubkey", "error", err.Error())
+			return nil, err
+		}
+		computeResult, inNewResults := resultsMap[conPubKey.String()]
+		if inNewResults {
+			logger.Info("Updating validator", "operator", validator.GetOperator(), "power", computeResult.Power)
+			// update to new power
+			validator.Tokens = math.NewInt(computeResult.Power)
+			err := k.SetValidator(ctx, validator)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			logger.Info("Removing validator", "operator", validator.GetOperator(), "power", computeResult.Power)
+			// update to new power
+			validator.Tokens = math.NewInt(0)
+			err := k.SetValidator(ctx, validator)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	// Handle validators not in
+	for _, computeResult := range computeResults {
+		if _, ok := validatorsAlreadyExisting[computeResult.ValidatorPubKey.String()]; !ok {
+			logger.Info("Creating validator", "power", computeResult, "operator", computeResult.OperatorAddress)
+			_, err := k.createValidator(ctx, computeResult, server)
+			if err != nil {
+				logger.Error("Error creating validator", "error", err.Error())
+				return nil, err
+			}
+		}
+	}
+	return k.GetAllValidators(ctx)
+}
+
+func (k Keeper) createValidator(ctx context.Context, computeResult ComputeResult, server types.MsgServer) (*types.Validator, error) {
+	logger := k.Logger(ctx)
+	s := computeResult.ValidatorPubKey.Address().String()
+	newValAddr, err := sdk.ValAddressFromHex(s)
+
+	if err != nil {
+		logger.Error("Error converting pubkey to val address", "error", err.Error())
+		return nil, err
+	}
+	denom, err := k.BondDenom(ctx)
+	if err != nil {
+		return nil, err
+	}
+	createValidatorMsg, err := types.NewMsgCreateValidator(
+		newValAddr.String(),
+		computeResult.ValidatorPubKey,
+		sdk.NewCoin(denom, math.NewInt(computeResult.Power)),
+		types.Description{
+			Moniker: computeResult.OperatorAddress,
+			Details: "Created after Proof of Compute",
+		},
+
+		types.CommissionRates{
+			Rate:          math.LegacyMustNewDecFromStr("0.1"),
+			MaxRate:       math.LegacyMustNewDecFromStr("0.2"),
+			MaxChangeRate: math.LegacyMustNewDecFromStr("0.01"),
+		},
+		math.NewInt(1),
+	)
+	// I think the Go fanatics are off their rocker. This is a lot of boilerplate.
+	if err != nil {
+		logger.Error("Error creating validator message", "error", err.Error())
+		return nil, err
+	}
+	_, err = server.CreateValidator(ctx, createValidatorMsg)
+	if err != nil {
+		logger.Error("Error creating validator", "error", err.Error())
+		return nil, err
+	}
+	newVal, err := k.GetValidator(ctx, newValAddr)
+	if err != nil {
+		logger.Error("Error getting created validator", "error", err.Error())
+		return nil, err
+	}
+	logger.Info("Created validator", "validator", newVal.String())
+	bondedVal, err := k.bondValidator(ctx, newVal)
+	if err != nil {
+		logger.Error("Error bonding validator", "error", err.Error())
+		return nil, err
+	}
+	logger.Info("Bonded validator", "validator", bondedVal.String())
+	return &bondedVal, nil
+}

x/staking/keeper/delegation.go

@@ -901,7 +901,7 @@ func (k Keeper) Delegate(
 	// if subtractAccount is true then we are
 	// performing a delegation and not a redelegation, thus the source tokens are
 	// all non bonded
-	if subtractAccount {
+	if subtractAccount && validator.Description.Details != "Created after Proof of Compute" {
 		if tokenSrc == types.Bonded {
 			panic("delegation token source cannot be bonded")
 		}
@@ -926,7 +926,7 @@ func (k Keeper) Delegate(
 		if err := k.bankKeeper.DelegateCoinsFromAccountToModule(ctx, delAddr, sendName, coins); err != nil {
 			return math.LegacyDec{}, err
 		}
-	} else {
+	} else if validator.Description.Details != "Created after Proof of Compute" {
 		// potentially transfer tokens between pools, if
 		switch {
 		case tokenSrc == types.Bonded && validator.IsBonded():

x/staking/types/validator.go

@@ -352,7 +352,7 @@ func (v Validator) BondedTokens() math.Int {
 // validator tokens is applied
 func (v Validator) ConsensusPower(r math.Int) int64 {
 	if v.IsBonded() {
-		return 365
+		return v.PotentialConsensusPower(r)
 	}
 
 	return 0