test: add additonal validatorPopReward reallocation test (#436)

* test: add additonal validatorPopReward reallocation test
* fix: linter & staticcheck errors
---------

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>

app/ante/check_machine_decorator.go

@@ -51,21 +51,21 @@ func (cm CheckMachineDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 func (cm CheckMachineDecorator) handleNotarizeAsset(ctx sdk.Context, notarizeMsg *assettypes.MsgNotarizeAsset) (sdk.Context, error) {
 	_, found := cm.mk.GetMachineIndexByAddress(ctx, notarizeMsg.GetCreator())
 	if !found {
-		return ctx, errorsmod.Wrapf(machinetypes.ErrMachineNotFound, ErrorAnteContext)
+		return ctx, errorsmod.Wrap(machinetypes.ErrMachineNotFound, ErrorAnteContext)
 	}
 	return ctx, nil
 }
 
 func (cm CheckMachineDecorator) handleAttestMachine(ctx sdk.Context, attestMsg *machinetypes.MsgAttestMachine) (sdk.Context, error) {
 	if attestMsg.GetCreator() != attestMsg.Machine.GetAddress() {
-		return ctx, errorsmod.Wrapf(machinetypes.ErrMachineIsNotCreator, ErrorAnteContext)
+		return ctx, errorsmod.Wrap(machinetypes.ErrMachineIsNotCreator, ErrorAnteContext)
 	}
 	_, activated, found := cm.mk.GetTrustAnchor(ctx, attestMsg.Machine.MachineId)
 	if !found {
-		return ctx, errorsmod.Wrapf(machinetypes.ErrTrustAnchorNotFound, ErrorAnteContext)
+		return ctx, errorsmod.Wrap(machinetypes.ErrTrustAnchorNotFound, ErrorAnteContext)
 	}
 	if activated {
-		return ctx, errorsmod.Wrapf(machinetypes.ErrTrustAnchorAlreadyInUse, ErrorAnteContext)
+		return ctx, errorsmod.Wrap(machinetypes.ErrTrustAnchorAlreadyInUse, ErrorAnteContext)
 	}
 	return ctx, nil
 }
@@ -73,7 +73,7 @@ func (cm CheckMachineDecorator) handleAttestMachine(ctx sdk.Context, attestMsg *
 func (cm CheckMachineDecorator) handlePopResult(ctx sdk.Context, popMsg *daotypes.MsgReportPopResult) (sdk.Context, error) {
 	_, found := cm.mk.GetMachineIndexByAddress(ctx, popMsg.GetCreator())
 	if !found {
-		return ctx, errorsmod.Wrapf(machinetypes.ErrMachineNotFound, ErrorAnteContext)
+		return ctx, errorsmod.Wrap(machinetypes.ErrMachineNotFound, ErrorAnteContext)
 	}
 	return ctx, nil
 }

app/ante/check_validator_decorator.go

@@ -53,7 +53,7 @@ func (cv CheckValidatorDecorator) handleMsg(ctx sdk.Context, msg sdk.Msg) (_ sdk
 	signer := msg.GetSigners()[0]
 	_, found := cv.sk.GetValidator(ctx, sdk.ValAddress(signer))
 	if !found {
-		return ctx, errorsmod.Wrapf(types.ErrRestrictedMsg, ErrorAnteContext)
+		return ctx, errorsmod.Wrap(types.ErrRestrictedMsg, ErrorAnteContext)
 	}
 	return ctx, nil
 }

app/ante/deduct_fee_decorator.go

@@ -166,7 +166,7 @@ func (dfd DeductFeeDecorator) deductFees(bankKeeper authtypes.BankKeeper, ctx sd
 
 	err := bankKeeper.SendCoinsFromAccountToModule(ctx, acc.GetAddress(), authtypes.FeeCollectorName, fees)
 	if err != nil {
-		return errorsmod.Wrapf(sdkerrors.ErrInsufficientFunds, err.Error())
+		return errorsmod.Wrap(sdkerrors.ErrInsufficientFunds, err.Error())
 	}
 
 	return nil

app/ante/setup_context_decorator.go

@@ -39,7 +39,7 @@ func (sud SetUpContextDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 		// Set a gas meter with limit 0 as to prevent an infinite gas meter attack
 		// during runTx.
 		newCtx = SetGasMeter(simulate, ctx, 0)
-		return newCtx, errorsmod.Wrapf(sdkerrors.ErrTxDecode, "Tx must be GasTx")
+		return newCtx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "Tx must be GasTx")
 	}
 
 	gasLimit := sud.dk.GetTxGasLimit(ctx)
@@ -70,7 +70,7 @@ func (sud SetUpContextDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 					"out of gas in location: %v; gasWanted: %d, gasUsed: %d",
 					rType.Descriptor, gasTx.GetGas(), newCtx.GasMeter().GasConsumed())
 
-				err = errorsmod.Wrapf(sdkerrors.ErrOutOfGas, log)
+				err = errorsmod.Wrap(sdkerrors.ErrOutOfGas, log)
 			default:
 				panic(r)
 			}

monitor/mqtt_monitor.go

@@ -256,7 +256,7 @@ func IsLegitMachineAddress(address string) (active bool, err error) {
 
 	// Check the status code
 	if resp.StatusCode != http.StatusOK {
-		log.Printf("[app] [Monitor] Error: unexpected status code: " + string(body))
+		log.Print("[app] [Monitor] Error: unexpected status code: " + string(body))
 		return
 	}
 

util/logger.go

@@ -54,7 +54,7 @@ func (logger *AppLogger) testingLog(msg string, keyvals ...interface{}) {
 		return
 	}
 	msg = format(msg, keyvals...)
-	logger.testingLogger.Logf(msg)
+	logger.testingLogger.Log(msg)
 }
 
 func (logger *AppLogger) Info(ctx sdk.Context, msg string, keyvals ...interface{}) {

x/dao/keeper/challenge.go

@@ -70,7 +70,7 @@ func (k Keeper) GetChallenges(ctx sdk.Context) (challenges []types.Challenge, er
 	return
 }
 
-func (k Keeper) storeChallangeInitiatorReward(ctx sdk.Context, height int64, amount uint64) {
+func (k Keeper) StoreChallangeInitiatorReward(ctx sdk.Context, height int64, amount uint64) {
 	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.PoPInitiatorReward))
 	appendValue := util.SerializeUint64(amount)
 	store.Set(util.SerializeInt64(height), appendValue)

x/dao/keeper/challenge_test.go

@@ -25,6 +25,7 @@ func createNChallenge(keeper *keeper.Keeper, ctx sdk.Context, n int, popEpochs i
 		items[i].Success = false
 		items[i].Finished = false
 		keeper.StoreChallenge(ctx, items[i])
+		keeper.StoreChallangeInitiatorReward(ctx, blockHeight, types.DefaultParams().ValidatorPopReward)
 	}
 	return items
 }

x/dao/keeper/distribution_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	keepertest "github.com/planetmint/planetmint-go/testutil/keeper"
+	"github.com/planetmint/planetmint-go/util"
 	"github.com/stretchr/testify/assert"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -91,3 +92,40 @@ func TestTokenDistribution(t *testing.T) {
 	assert.True(t, expSum-sum < 0.000001)
 	assert.Equal(t, float64(reissuances), Amount1stBatch+Amount2ndBatch)
 }
+
+func TestValidatorRewardReallocation(t *testing.T) {
+	t.Parallel()
+	k, ctx := keepertest.DaoKeeper(t)
+
+	// create reissuances
+	_ = createNReissuances(k, ctx, 1000, types.DefaultParams().PopEpochs)
+	distribution, err := k.GetDistributionForReissuedTokens(ctx, 780)
+	assert.NoError(t, err)
+
+	// create challenges
+	_ = createNChallenge(k, ctx, 250, types.DefaultParams().PopEpochs)
+	distributionWithPopReallocation, err := k.GetDistributionForReissuedTokens(ctx, 780)
+	assert.NoError(t, err)
+
+	// compare
+	pops := 780 / types.DefaultParams().PopEpochs
+	distributionDaoAmount, err := util.RDDLTokenStringToFloat(distribution.DaoAmount)
+	assert.NoError(t, err)
+	distributionPopAmount, err := util.RDDLTokenStringToFloat(distribution.PopAmount)
+	assert.NoError(t, err)
+
+	distributionWithValidatorPopRewardDao, err := util.RDDLTokenStringToFloat(distributionWithPopReallocation.DaoAmount)
+	assert.NoError(t, err)
+	distributionWithValidatorPopRewardPop, err := util.RDDLTokenStringToFloat(distributionWithPopReallocation.PopAmount)
+	assert.NoError(t, err)
+
+	// Some of DaoAmount is transferred to PopAmount
+	assert.Greater(t, distributionDaoAmount, distributionWithValidatorPopRewardDao)
+	assert.Greater(t, distributionWithValidatorPopRewardPop, distributionPopAmount)
+
+	diffPopAmount := distributionWithValidatorPopRewardPop - distributionPopAmount
+	diffDaoAmount := distributionDaoAmount - distributionWithValidatorPopRewardDao
+	assert.Equal(t, diffPopAmount, diffDaoAmount)
+	assert.Equal(t, pops, int64(diffPopAmount))
+	assert.Equal(t, pops, int64(diffDaoAmount))
+}

x/dao/keeper/msg_server_init_pop.go

@@ -25,7 +25,7 @@ func (k msgServer) InitPop(goCtx context.Context, msg *types.MsgInitPop) (*types
 	k.StoreChallenge(ctx, challenge)
 
 	amount := k.GetValidatorPoPReward(ctx)
-	k.storeChallangeInitiatorReward(ctx, msg.GetHeight(), amount)
+	k.StoreChallangeInitiatorReward(ctx, msg.GetHeight(), amount)
 
 	validatorIdentity, err := util.GetValidatorCometBFTIdentity(ctx, k.RootDir)
 	if err != nil {

x/dao/keeper/msg_server_reissue_rddl_proposal.go

@@ -58,7 +58,7 @@ func (k msgServer) validateReissuanceProposal(ctx sdk.Context, msg *types.MsgRei
 	isValid := k.IsValidReissuanceProposal(ctx, msg)
 	if !isValid {
 		util.GetAppLogger().Info(ctx, reissueTag+"rejected reissuance proposal")
-		return errorsmod.Wrapf(types.ErrReissuanceProposal, reissueTag)
+		return errorsmod.Wrap(types.ErrReissuanceProposal, reissueTag)
 	}
 	util.GetAppLogger().Debug(ctx, reissueTag+"accepted reissuance proposal: "+msg.String())
 	return

x/dao/keeper/msg_server_report_pop_result.go

@@ -35,7 +35,7 @@ func (k msgServer) ReportPopResult(goCtx context.Context, msg *types.MsgReportPo
 
 	err := util.ValidateStruct(*msg.Challenge)
 	if err != nil {
-		return nil, errorsmod.Wrapf(types.ErrInvalidChallenge, err.Error())
+		return nil, errorsmod.Wrap(types.ErrInvalidChallenge, err.Error())
 	}
 
 	// verify that the report origin is the challenger
@@ -64,7 +64,7 @@ func (k msgServer) ReportPopResult(goCtx context.Context, msg *types.MsgReportPo
 
 	err = k.issuePoPRewards(ctx, *msg.Challenge)
 	if err != nil {
-		return nil, errorsmod.Wrapf(types.ErrFailedPoPRewardsIssuance, err.Error())
+		return nil, errorsmod.Wrap(types.ErrFailedPoPRewardsIssuance, err.Error())
 	}
 
 	return &types.MsgReportPopResultResponse{}, nil