Add simulated distribution msgs

cmd/gaia/app/sim_test.go

@@ -16,6 +16,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	banksim "github.com/cosmos/cosmos-sdk/x/bank/simulation"
 	distr "github.com/cosmos/cosmos-sdk/x/distribution"
+	distributionsim "github.com/cosmos/cosmos-sdk/x/distribution/simulation"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	govsim "github.com/cosmos/cosmos-sdk/x/gov/simulation"
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
@@ -103,6 +104,10 @@ func appStateFn(r *rand.Rand, accs []simulation.Account) json.RawMessage {
 func testAndRunTxs(app *GaiaApp) []simulation.WeightedOperation {
 	return []simulation.WeightedOperation{
 		{100, banksim.SingleInputSendMsg(app.accountMapper, app.bankKeeper)},
+		{50, distributionsim.SimulateMsgSetWithdrawAddress(app.accountMapper, app.distrKeeper)},
+		{50, distributionsim.SimulateMsgWithdrawDelegatorRewardsAll(app.accountMapper, app.distrKeeper)},
+		{50, distributionsim.SimulateMsgWithdrawDelegatorReward(app.accountMapper, app.distrKeeper)},
+		{50, distributionsim.SimulateMsgWithdrawValidatorRewardsAll(app.accountMapper, app.distrKeeper)},
 		{5, govsim.SimulateSubmittingVotingAndSlashingForProposal(app.govKeeper, app.stakeKeeper)},
 		{100, govsim.SimulateMsgDeposit(app.govKeeper, app.stakeKeeper)},
 		{100, stakesim.SimulateMsgCreateValidator(app.accountMapper, app.stakeKeeper)},
@@ -117,6 +122,7 @@ func testAndRunTxs(app *GaiaApp) []simulation.WeightedOperation {
 func invariants(app *GaiaApp) []simulation.Invariant {
 	return []simulation.Invariant{
 		banksim.NonnegativeBalanceInvariant(app.accountMapper),
+		distributionsim.AllInvariants(app.bankKeeper, app.distrKeeper, app.accountMapper),
 		govsim.AllInvariants(),
 		stakesim.AllInvariants(app.bankKeeper, app.stakeKeeper, app.accountMapper),
 		slashingsim.AllInvariants(),

x/distribution/alias.go

@@ -49,7 +49,7 @@ var (
 
 	NewMsgSetWithdrawAddress          = types.NewMsgSetWithdrawAddress
 	NewMsgWithdrawDelegatorRewardsAll = types.NewMsgWithdrawDelegatorRewardsAll
-	NewMsgWithdrawDelegationReward    = types.NewMsgWithdrawDelegatorReward
+	NewMsgWithdrawDelegatorReward     = types.NewMsgWithdrawDelegatorReward
 	NewMsgWithdrawValidatorRewardsAll = types.NewMsgWithdrawValidatorRewardsAll
 )
 

x/distribution/simulation/invariants.go

@@ -0,0 +1,17 @@
+package simulation
+
+import (
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/distribution"
+	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+)
+
+// AllInvariants runs all invariants of the distribution module.
+// Currently: total supply, positive power
+func AllInvariants(ck bank.Keeper, k distribution.Keeper, am auth.AccountMapper) simulation.Invariant {
+	return func(app *baseapp.BaseApp) error {
+		return nil
+	}
+}

x/distribution/simulation/msgs.go

@@ -0,0 +1,130 @@
+package simulation
+
+import (
+	"fmt"
+	"math/rand"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/distribution"
+	"github.com/cosmos/cosmos-sdk/x/mock"
+	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+)
+
+// SimulateMsgSetWithdrawAddress
+func SimulateMsgSetWithdrawAddress(m auth.AccountMapper, k distribution.Keeper) simulation.Operation {
+	handler := distribution.NewHandler(k)
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
+		accs []simulation.Account, event func(string)) (
+		action string, fOp []simulation.FutureOperation, err error) {
+
+		accountOrigin := simulation.RandomAcc(r, accs)
+		accountDestination := simulation.RandomAcc(r, accs)
+		msg := distribution.NewMsgSetWithdrawAddress(accountOrigin.Address, accountDestination.Address)
+
+		if msg.ValidateBasic() != nil {
+			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+		}
+
+		ctx, write := ctx.CacheContext()
+		result := handler(ctx, msg)
+		if result.IsOK() {
+			write()
+		}
+
+		event(fmt.Sprintf("distribution/MsgSetWithdrawAddress/%v", result.IsOK()))
+
+		action = fmt.Sprintf("TestMsgSetWithdrawAddress: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
+		return action, nil, nil
+	}
+}
+
+// SimulateMsgWithdrawDelegatorRewardsAll
+func SimulateMsgWithdrawDelegatorRewardsAll(m auth.AccountMapper, k distribution.Keeper) simulation.Operation {
+	handler := distribution.NewHandler(k)
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
+		accs []simulation.Account, event func(string)) (
+		action string, fOp []simulation.FutureOperation, err error) {
+
+		account := simulation.RandomAcc(r, accs)
+		msg := distribution.NewMsgWithdrawDelegatorRewardsAll(account.Address)
+
+		if msg.ValidateBasic() != nil {
+			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+		}
+
+		ctx, write := ctx.CacheContext()
+		result := handler(ctx, msg)
+		if result.IsOK() {
+			write()
+		}
+
+		event(fmt.Sprintf("distribution/MsgWithdrawDelegatorRewardsAll/%v", result.IsOK()))
+
+		action = fmt.Sprintf("TestMsgWithdrawDelegatorRewardsAll: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
+		return action, nil, nil
+	}
+}
+
+// SimulateMsgWithdrawDelegatorReward
+func SimulateMsgWithdrawDelegatorReward(m auth.AccountMapper, k distribution.Keeper) simulation.Operation {
+	handler := distribution.NewHandler(k)
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
+		accs []simulation.Account, event func(string)) (
+		action string, fOp []simulation.FutureOperation, err error) {
+
+		delegatorAccount := simulation.RandomAcc(r, accs)
+		validatorAccount := simulation.RandomAcc(r, accs)
+		msg := distribution.NewMsgWithdrawDelegatorReward(delegatorAccount.Address, sdk.ValAddress(validatorAccount.Address))
+
+		if msg.ValidateBasic() != nil {
+			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+		}
+
+		ctx, write := ctx.CacheContext()
+		result := handler(ctx, msg)
+		if result.IsOK() {
+			write()
+		}
+
+		event(fmt.Sprintf("distribution/MsgWithdrawDelegatorReward/%v", result.IsOK()))
+
+		action = fmt.Sprintf("TestMsgWithdrawDelegatorReward: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
+		return action, nil, nil
+	}
+}
+
+// SimulateMsgWithdrawValidatorRewardsAll
+func SimulateMsgWithdrawValidatorRewardsAll(m auth.AccountMapper, k distribution.Keeper) simulation.Operation {
+	handler := distribution.NewHandler(k)
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
+		accs []simulation.Account, event func(string)) (
+		action string, fOp []simulation.FutureOperation, err error) {
+
+		account := simulation.RandomAcc(r, accs)
+		msg := distribution.NewMsgWithdrawValidatorRewardsAll(sdk.ValAddress(account.Address))
+
+		if msg.ValidateBasic() != nil {
+			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+		}
+
+		ctx, write := ctx.CacheContext()
+		result := handler(ctx, msg)
+		if result.IsOK() {
+			write()
+		}
+
+		event(fmt.Sprintf("distribution/MsgWithdrawValidatorRewardsAll/%v", result.IsOK()))
+
+		action = fmt.Sprintf("TestMsgWithdrawValidatorRewardsAll: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
+		return action, nil, nil
+	}
+}
+
+// Setup
+// nolint: errcheck
+func Setup(mapp *mock.App, k distribution.Keeper) simulation.RandSetup {
+	return func(r *rand.Rand, accs []simulation.Account) {
+	}
+}