R4R: Slashing, validator set, and governance simulation

Makefile

@@ -139,7 +139,11 @@ test_sim:
 	@echo "Pass the flag 'SimulationNumKeys' to run with the specified number of keys."
 	@echo "Pass the flag 'SimulationNumBlocks' to run with the specified number of blocks."
 	@echo "Pass the flag 'SimulationBlockSize' to run with the specified block size (operations per block)."
-	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationBlockSize=200 -v
+	@echo "Pass the flag 'SimulationMinTimePerBlock' to run with the specified minimum block time."
+	@echo "Pass the flag 'SimulationMaxTimePerBlock' to run with the specified maximum block time."
+	@echo "Pass the flag 'SimulationSigningFraction' to run with the specified chance of a given validator signing a given block."
+	@echo "Pass the flag 'SimulationEvidenceFraction' to run with the specified chance of finding evidence on a given block."
+	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -v
 
 test_cover:
 	@bash tests/test_cover.sh

cmd/gaia/app/sim_test.go

@@ -8,47 +8,72 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/tendermint/tendermint/crypto"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
 
+	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	banksim "github.com/cosmos/cosmos-sdk/x/bank/simulation"
+	govsim "github.com/cosmos/cosmos-sdk/x/gov/simulation"
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation"
 	stake "github.com/cosmos/cosmos-sdk/x/stake"
 	stakesim "github.com/cosmos/cosmos-sdk/x/stake/simulation"
 )
 
 var (
-	seed      int64
-	numKeys   int
-	numBlocks int
-	blockSize int
-	enabled   bool
+	seed             int64
+	numKeys          int
+	numBlocks        int
+	blockSize        int
+	minTimePerBlock  int64
+	maxTimePerBlock  int64
+	signingFraction  float64
+	evidenceFraction float64
+	enabled          bool
 )
 
 func init() {
 	flag.Int64Var(&seed, "SimulationSeed", 42, "Simulation random seed")
-	flag.IntVar(&numKeys, "SimulationNumKeys", 10, "Number of keys (accounts)")
-	flag.IntVar(&numBlocks, "SimulationNumBlocks", 100, "Number of blocks")
-	flag.IntVar(&blockSize, "SimulationBlockSize", 100, "Operations per block")
+	flag.IntVar(&numKeys, "SimulationNumKeys", 1000, "Number of keys (accounts)")
+	flag.IntVar(&numBlocks, "SimulationNumBlocks", 1000, "Number of blocks")
+	flag.IntVar(&blockSize, "SimulationBlockSize", 200, "Operations per block")
+	flag.Int64Var(&minTimePerBlock, "SimulationMinTimePerBlock", 86400, "Minimum time per block (seconds)")
+	flag.Int64Var(&maxTimePerBlock, "SimulationMaxTimePerBlock", 2*86400, "Maximum time per block (seconds)")
+	flag.Float64Var(&signingFraction, "SimulationSigningFraction", 0.7, "Chance a given validator signs a given block")
+	flag.Float64Var(&evidenceFraction, "SimulationEvidenceFraction", 0.01, "Chance that any evidence is found on a given block")
 	flag.BoolVar(&enabled, "SimulationEnabled", false, "Enable the simulation")
 }
 
-func appStateFn(r *rand.Rand, accs []sdk.AccAddress) json.RawMessage {
+func appStateFn(r *rand.Rand, keys []crypto.PrivKey, accs []sdk.AccAddress) json.RawMessage {
 	var genesisAccounts []GenesisAccount
 
 	// Randomly generate some genesis accounts
-	for _, addr := range accs {
+	for _, acc := range accs {
 		coins := sdk.Coins{sdk.Coin{"steak", sdk.NewInt(100)}}
 		genesisAccounts = append(genesisAccounts, GenesisAccount{
-			Address: addr,
+			Address: acc,
 			Coins:   coins,
 		})
 	}
 
 	// Default genesis state
 	stakeGenesis := stake.DefaultGenesisState()
-	stakeGenesis.Pool.LooseTokens = sdk.NewRat(1000)
+	var validators []stake.Validator
+	var delegations []stake.Delegation
+	numInitiallyBonded := int64(50)
+	for i := 0; i < int(numInitiallyBonded); i++ {
+		validator := stake.NewValidator(accs[i], keys[i].PubKey(), stake.Description{})
+		validator.Tokens = sdk.NewRat(100)
+		validator.DelegatorShares = sdk.NewRat(100)
+		delegation := stake.Delegation{accs[i], accs[i], sdk.NewRat(100), 0}
+		validators = append(validators, validator)
+		delegations = append(delegations, delegation)
+	}
+	stakeGenesis.Pool.LooseTokens = sdk.NewRat(int64(100*numKeys) + (numInitiallyBonded * 100))
+	stakeGenesis.Validators = validators
+	stakeGenesis.Bonds = delegations
 	genesis := GenesisState{
 		Accounts:  genesisAccounts,
 		StakeData: stakeGenesis,
@@ -74,27 +99,41 @@ func TestFullGaiaSimulation(t *testing.T) {
 	app := NewGaiaApp(logger, db, nil)
 	require.Equal(t, "GaiaApp", app.Name())
 
+	allInvariants := func(t *testing.T, baseapp *baseapp.BaseApp, log string) {
+		banksim.NonnegativeBalanceInvariant(app.accountMapper)(t, baseapp, log)
+		govsim.AllInvariants()(t, baseapp, log)
+		stakesim.AllInvariants(app.coinKeeper, app.stakeKeeper, app.accountMapper)(t, baseapp, log)
+		slashingsim.AllInvariants()(t, baseapp, log)
+	}
+
 	// Run randomized simulation
 	simulation.SimulateFromSeed(
 		t, app.BaseApp, appStateFn, seed,
 		[]simulation.TestAndRunTx{
 			banksim.TestAndRunSingleInputMsgSend(app.accountMapper),
+			govsim.SimulateMsgSubmitProposal(app.govKeeper, app.stakeKeeper),
+			govsim.SimulateMsgDeposit(app.govKeeper, app.stakeKeeper),
+			govsim.SimulateMsgVote(app.govKeeper, app.stakeKeeper),
 			stakesim.SimulateMsgCreateValidator(app.accountMapper, app.stakeKeeper),
 			stakesim.SimulateMsgEditValidator(app.stakeKeeper),
 			stakesim.SimulateMsgDelegate(app.accountMapper, app.stakeKeeper),
-			stakesim.SimulateMsgBeginUnbonding(app.accountMapper, app.stakeKeeper),
+			//stakesim.SimulateMsgBeginUnbonding(app.accountMapper, app.stakeKeeper),
 			stakesim.SimulateMsgCompleteUnbonding(app.stakeKeeper),
 			stakesim.SimulateMsgBeginRedelegate(app.accountMapper, app.stakeKeeper),
 			stakesim.SimulateMsgCompleteRedelegate(app.stakeKeeper),
+			slashingsim.SimulateMsgUnrevoke(app.slashingKeeper),
 		},
 		[]simulation.RandSetup{},
 		[]simulation.Invariant{
-			banksim.NonnegativeBalanceInvariant(app.accountMapper),
-			stakesim.AllInvariants(app.coinKeeper, app.stakeKeeper, app.accountMapper),
+			simulation.PeriodicInvariant(allInvariants, 100, 0),
 		},
 		numKeys,
 		numBlocks,
 		blockSize,
+		minTimePerBlock,
+		maxTimePerBlock,
+		signingFraction,
+		evidenceFraction,
 	)
 
 }

docs/sdk/core/examples/app2_test.go

@@ -1,9 +1,9 @@
 package app
 
 import (
-	"testing"
-	"github.com/tendermint/tendermint/crypto"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/tendermint/tendermint/crypto"
+	"testing"
 
 	"github.com/stretchr/testify/require"
 )
@@ -17,8 +17,8 @@ func TestEncoding(t *testing.T) {
 	addr2 := priv2.PubKey().Address().Bytes()
 
 	sendMsg := MsgSend{
-		From: addr1,
-		To: addr2,
+		From:   addr1,
+		To:     addr2,
 		Amount: sdk.Coins{{"testCoins", sdk.NewInt(100)}},
 	}
 
@@ -30,8 +30,8 @@ func TestEncoding(t *testing.T) {
 	}
 
 	sendTxBefore := app2Tx{
-		Msg: sendMsg,
-		PubKey: priv1.PubKey(),
+		Msg:       sendMsg,
+		PubKey:    priv1.PubKey(),
 		Signature: sig,
 	}
 
@@ -47,13 +47,13 @@ func TestEncoding(t *testing.T) {
 	require.Nil(t, err, "Error decoding sendTx")
 
 	sendTxAfter := tx1.(app2Tx)
-	
+
 	require.Equal(t, sendTxBefore, sendTxAfter, "Transaction changed after encoding/decoding")
 
 	issueMsg := MsgIssue{
-		Issuer: addr1,
+		Issuer:   addr1,
 		Receiver: addr2,
-		Coin: sdk.Coin{"testCoin", sdk.NewInt(100)},
+		Coin:     sdk.Coin{"testCoin", sdk.NewInt(100)},
 	}
 
 	signBytes = issueMsg.GetSignBytes()
@@ -63,8 +63,8 @@ func TestEncoding(t *testing.T) {
 	}
 
 	issueTxBefore := app2Tx{
-		Msg: issueMsg,
-		PubKey: priv1.PubKey(),
+		Msg:       issueMsg,
+		PubKey:    priv1.PubKey(),
 		Signature: sig,
 	}
 
@@ -80,4 +80,4 @@ func TestEncoding(t *testing.T) {
 
 	require.Equal(t, issueTxBefore, issueTxAfter, "Transaction changed after encoding/decoding")
 
-}
+}

docs/sdk/core/examples/app3.go

@@ -1,16 +1,16 @@
 package app
 
 import (
+	"github.com/tendermint/tendermint/crypto"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/crypto"
 
 	bapp "github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
-	"github.com/cosmos/cosmos-sdk/wire"
 )
 
 const (

docs/sdk/core/examples/app4_test.go

@@ -1,14 +1,14 @@
 package app
 
 import (
-	"github.com/stretchr/testify/require"
-	"os"
 	"encoding/json"
-	"testing"
-	dbm "github.com/tendermint/tendermint/libs/db"
-	"github.com/tendermint/tendermint/libs/log"
+	"github.com/stretchr/testify/require"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
+	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/tendermint/tendermint/libs/log"
+	"os"
+	"testing"
 
 	bapp "github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -44,7 +44,7 @@ func InitTestChain(bc *bapp.BaseApp, chainID string, addrs ...sdk.AccAddress) {
 // Generate basic SpendMsg with one input and output
 func GenerateSpendMsg(sender, receiver sdk.AccAddress, amount sdk.Coins) bank.MsgSend {
 	return bank.MsgSend{
-		Inputs: []bank.Input{{sender, amount}},
+		Inputs:  []bank.Input{{sender, amount}},
 		Outputs: []bank.Output{{receiver, amount}},
 	}
 }
@@ -64,26 +64,26 @@ func TestBadMsg(t *testing.T) {
 
 	// Construct transaction
 	fee := auth.StdFee{
-		Gas: 1000000000000000,
+		Gas:    1000000000000000,
 		Amount: sdk.Coins{{"testCoin", sdk.NewInt(0)}},
 	}
 	signBytes := auth.StdSignBytes("test-chain", 0, 0, fee, []sdk.Msg{msg}, "")
 	sig, err := priv1.Sign(signBytes)
 	if err != nil {
 		panic(err)
 	}
-	sigs := []auth.StdSignature{auth.StdSignature{
-		PubKey: priv1.PubKey(),
-		Signature: sig,
+	sigs := []auth.StdSignature{{
+		PubKey:        priv1.PubKey(),
+		Signature:     sig,
 		AccountNumber: 0,
-		Sequence: 0,
+		Sequence:      0,
 	}}
 
 	tx := auth.StdTx{
-		Msgs: []sdk.Msg{msg},
-		Fee:  fee,
+		Msgs:       []sdk.Msg{msg},
+		Fee:        fee,
 		Signatures: sigs,
-		Memo: "",
+		Memo:       "",
 	}
 
 	bc.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{ChainID: "test-chain"}})
@@ -110,26 +110,26 @@ func TestMsgSend(t *testing.T) {
 	msg := GenerateSpendMsg(addr1, addr2, sdk.Coins{{"testCoin", sdk.NewInt(100)}})
 
 	fee := auth.StdFee{
-		Gas: 1000000000000000,
+		Gas:    1000000000000000,
 		Amount: sdk.Coins{{"testCoin", sdk.NewInt(0)}},
 	}
 	signBytes := auth.StdSignBytes("test-chain", 0, 0, fee, []sdk.Msg{msg}, "")
 	sig, err := priv1.Sign(signBytes)
 	if err != nil {
 		panic(err)
 	}
-	sigs := []auth.StdSignature{auth.StdSignature{
-		PubKey: priv1.PubKey(),
-		Signature: sig,
+	sigs := []auth.StdSignature{{
+		PubKey:        priv1.PubKey(),
+		Signature:     sig,
 		AccountNumber: 0,
-		Sequence: 0,
+		Sequence:      0,
 	}}
 
 	tx := auth.StdTx{
-		Msgs: []sdk.Msg{msg},
-		Fee:  fee,
+		Msgs:       []sdk.Msg{msg},
+		Fee:        fee,
 		Signatures: sigs,
-		Memo: "",
+		Memo:       "",
 	}
 
 	bc.BeginBlock(abci.RequestBeginBlock{})
@@ -138,5 +138,4 @@ func TestMsgSend(t *testing.T) {
 
 	require.True(t, res.IsOK(), res.Log)
 
-
-}
+}

x/bank/app_test.go

@@ -112,8 +112,8 @@ func TestMsgSendWithAccounts(t *testing.T) {
 			expPass:  true,
 			privKeys: []crypto.PrivKey{priv1},
 			expectedBalances: []expectedBalance{
-				expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 57)}},
-				expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
+				{addr1, sdk.Coins{sdk.NewCoin("foocoin", 57)}},
+				{addr2, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
 			},
 		},
 		{
@@ -168,9 +168,9 @@ func TestMsgSendMultipleOut(t *testing.T) {
 			expPass:  true,
 			privKeys: []crypto.PrivKey{priv1},
 			expectedBalances: []expectedBalance{
-				expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
-				expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 47)}},
-				expectedBalance{addr3, sdk.Coins{sdk.NewCoin("foocoin", 5)}},
+				{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
+				{addr2, sdk.Coins{sdk.NewCoin("foocoin", 47)}},
+				{addr3, sdk.Coins{sdk.NewCoin("foocoin", 5)}},
 			},
 		},
 	}
@@ -210,10 +210,10 @@ func TestSengMsgMultipleInOut(t *testing.T) {
 			expPass:  true,
 			privKeys: []crypto.PrivKey{priv1, priv4},
 			expectedBalances: []expectedBalance{
-				expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
-				expectedBalance{addr4, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
-				expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 52)}},
-				expectedBalance{addr3, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
+				{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
+				{addr4, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
+				{addr2, sdk.Coins{sdk.NewCoin("foocoin", 52)}},
+				{addr3, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
 			},
 		},
 	}
@@ -245,8 +245,8 @@ func TestMsgSendDependent(t *testing.T) {
 			expPass:  true,
 			privKeys: []crypto.PrivKey{priv1},
 			expectedBalances: []expectedBalance{
-				expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
-				expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
+				{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
+				{addr2, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
 			},
 		},
 		{
@@ -256,7 +256,7 @@ func TestMsgSendDependent(t *testing.T) {
 			expPass:  true,
 			privKeys: []crypto.PrivKey{priv2},
 			expectedBalances: []expectedBalance{
-				expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 42)}},
+				{addr1, sdk.Coins{sdk.NewCoin("foocoin", 42)}},
 			},
 		},
 	}