Add delegation to our staking override

We need delegation for voting to work.
Also:
1. Don't send an ValidatorUpdate for validators with zero power (when they are removed).
2. Compute totalBonded manually, since we don't do bonding either.

Author: patimen

x/group/keeper/msg_server.go

@@ -24,7 +24,7 @@ var _ group.MsgServer = Keeper{}
 
 // TODO: Revisit this once we have proper gas fee framework.
 // Tracking issues https://github.com/cosmos/cosmos-sdk/issues/9054, https://github.com/cosmos/cosmos-sdk/discussions/9072
-const gasCostPerIteration = uint64(20)
+const gasCostPerIteration = uint64(0)
 
 func (k Keeper) CreateGroup(goCtx context.Context, msg *group.MsgCreateGroup) (*group.MsgCreateGroupResponse, error) {
 	if _, err := k.accKeeper.AddressCodec().StringToBytes(msg.Admin); err != nil {

x/group/keeper/proposal_executor.go

@@ -76,7 +76,7 @@ func ensureMsgAuthZ(msgs []sdk.Msg, groupPolicyAcc sdk.AccAddress, cdc codec.Cod
 
 		for _, acct := range signers {
 			if !bytes.Equal(groupPolicyAcc, acct) {
-				return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "msg does not have group policy authorization; expected %s, got %s", groupPolicyAcc.String(), acct)
+				return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "msg does not have group policy authorization; expected %x, got %x", groupPolicyAcc.Bytes(), acct)
 			}
 		}
 	}

x/staking/keeper/abci.go

@@ -27,6 +27,10 @@ func (k *Keeper) EndBlocker(ctx context.Context) ([]abci.ValidatorUpdate, error)
 	updates := make([]abci.ValidatorUpdate, 0, len(allValidators))
 	for _, validator := range allValidators {
 		update := validator.ABCIValidatorUpdate(math.NewInt(1))
+		if update.Power == 0 {
+			k.Logger(ctx).Info("Validator has no power, skipping update", "validator", update)
+			continue
+		}
 		updates = append(updates, update)
 		k.Logger(ctx).Info("UpdateValidator:", "pubKey", update.PubKey, "power", update.Power)
 	}

x/staking/keeper/compute.go

@@ -18,6 +18,7 @@ func (k Keeper) SetComputeValidators(ctx context.Context, computeResults []Compu
 	server := NewMsgServerImpl(&k)
 	logger := k.Logger(ctx)
 	resultsMap := make(map[string]ComputeResult)
+	totalBonded := 0
 	for _, result := range computeResults {
 		resultsMap[result.ValidatorPubKey.String()] = result
 	}
@@ -54,11 +55,20 @@ func (k Keeper) SetComputeValidators(ctx context.Context, computeResults []Compu
 			if err != nil {
 				return nil, err
 			}
+			err = k.delegateResult(ctx, computeResult, validator.OperatorAddress)
+			if err != nil {
+				return nil, err
+			}
+			totalBonded += int(computeResult.Power)
 		} 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)
+			k.RemoveDelegation(ctx, types.Delegation{
+				DelegatorAddress: computeResult.OperatorAddress,
+				ValidatorAddress: validator.OperatorAddress,
+			})
 			if err != nil {
 				return nil, err
 			}
@@ -69,16 +79,31 @@ func (k Keeper) SetComputeValidators(ctx context.Context, computeResults []Compu
 	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)
+			newVal, err := k.createValidator(ctx, computeResult, server)
 			if err != nil {
 				logger.Error("Error creating validator", "error", err.Error())
 				return nil, err
 			}
+			err = k.delegateResult(ctx, computeResult, newVal.OperatorAddress)
+			if err != nil {
+				logger.Error("Error delegating result", "error", err.Error())
+				return nil, err
+			}
+			totalBonded += int(computeResult.Power)
 		}
 	}
 	return k.GetAllValidators(ctx)
 }
 
+func (k Keeper) delegateResult(ctx context.Context, computeResult ComputeResult, validatorAddress string) error {
+	delegation := types.Delegation{
+		DelegatorAddress: computeResult.OperatorAddress,
+		ValidatorAddress: validatorAddress,
+	}
+	delegation.Shares = math.LegacyNewDec(computeResult.Power)
+	return k.SetDelegation(ctx, delegation)
+}
+
 func (k Keeper) createValidator(ctx context.Context, computeResult ComputeResult, server types.MsgServer) (*types.Validator, error) {
 	logger := k.Logger(ctx)
 	s := computeResult.ValidatorPubKey.Address().String()

x/staking/keeper/pool.go

@@ -77,12 +77,18 @@ func (k Keeper) burnNotBondedTokens(ctx context.Context, amt math.Int) error {
 
 // TotalBondedTokens total staking tokens supply which is bonded
 func (k Keeper) TotalBondedTokens(ctx context.Context) (math.Int, error) {
-	bondedPool := k.GetBondedPool(ctx)
-	bondDenom, err := k.BondDenom(ctx)
+	// PoC OVERRIDE: We don't deal with bonded tokens in banks (no deposit), just validator tokens
+	validators, err := k.GetAllValidators(ctx)
 	if err != nil {
 		return math.ZeroInt(), err
 	}
-	return k.bankKeeper.GetBalance(ctx, bondedPool.GetAddress(), bondDenom).Amount, nil
+	totalBonded := math.ZeroInt()
+	for _, validator := range validators {
+		if validator.IsBonded() {
+			totalBonded = totalBonded.Add(validator.GetTokens())
+		}
+	}
+	return totalBonded, nil
 }
 
 // StakingTokenSupply staking tokens from the total supply