diff --git a/.pending/breaking/sdk/3972-supply b/.pending/breaking/sdk/3972-supply new file mode 100644 index 000000000..18502d3d7 --- /dev/null +++ b/.pending/breaking/sdk/3972-supply @@ -0,0 +1,9 @@ +#4255 Add supply module that passively tracks the supplies of a chain +- Introduce `ModuleAccount` type, which tracks the flow of coins held within a module +- Replaced `FeeCollectorKeeper` for a `ModuleAccount` +- Replaced the staking `Pool`, which coins are now held by the `BondedPool` and `NotBonded` module accounts + - The `NotBonded` module account now only keeps track of the not bonded tokens within staking, instead of the whole chain +- #3628 Replaced governance's burn and deposit accounts for a `ModuleAccount` +- Added a `ModuleAccount` for the distribution module +- Added a `ModuleAccount` for the mint module +#4472 validation for crisis genesis \ No newline at end of file diff --git a/simapp/app.go b/simapp/app.go index 49782374e..89d7c124b 100644 --- a/simapp/app.go +++ b/simapp/app.go @@ -15,11 +15,11 @@ import ( "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/version" "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/cosmos/cosmos-sdk/x/auth/genaccounts" "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/crisis" distr "github.com/cosmos/cosmos-sdk/x/distribution" distrclient "github.com/cosmos/cosmos-sdk/x/distribution/client" + "github.com/cosmos/cosmos-sdk/x/genaccounts" "github.com/cosmos/cosmos-sdk/x/genutil" "github.com/cosmos/cosmos-sdk/x/gov" "github.com/cosmos/cosmos-sdk/x/mint" @@ -27,6 +27,7 @@ import ( paramsclient "github.com/cosmos/cosmos-sdk/x/params/client" "github.com/cosmos/cosmos-sdk/x/slashing" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" ) const appName = "SimApp" @@ -53,6 +54,7 @@ var ( params.AppModuleBasic{}, crisis.AppModuleBasic{}, slashing.AppModuleBasic{}, + supply.AppModuleBasic{}, ) ) @@ -73,30 +75,30 @@ type SimApp struct { invCheckPeriod uint // keys to access the substores - keyMain *sdk.KVStoreKey - keyAccount *sdk.KVStoreKey - keyStaking *sdk.KVStoreKey - tkeyStaking *sdk.TransientStoreKey - keySlashing *sdk.KVStoreKey - keyMint *sdk.KVStoreKey - keyDistr *sdk.KVStoreKey - tkeyDistr *sdk.TransientStoreKey - keyGov *sdk.KVStoreKey - keyFeeCollection *sdk.KVStoreKey - keyParams *sdk.KVStoreKey - tkeyParams *sdk.TransientStoreKey + keyMain *sdk.KVStoreKey + keyAccount *sdk.KVStoreKey + keySupply *sdk.KVStoreKey + keyStaking *sdk.KVStoreKey + tkeyStaking *sdk.TransientStoreKey + keySlashing *sdk.KVStoreKey + keyMint *sdk.KVStoreKey + keyDistr *sdk.KVStoreKey + tkeyDistr *sdk.TransientStoreKey + keyGov *sdk.KVStoreKey + keyParams *sdk.KVStoreKey + tkeyParams *sdk.TransientStoreKey // keepers - accountKeeper auth.AccountKeeper - feeCollectionKeeper auth.FeeCollectionKeeper - bankKeeper bank.Keeper - stakingKeeper staking.Keeper - slashingKeeper slashing.Keeper - mintKeeper mint.Keeper - distrKeeper distr.Keeper - govKeeper gov.Keeper - crisisKeeper crisis.Keeper - paramsKeeper params.Keeper + accountKeeper auth.AccountKeeper + bankKeeper bank.Keeper + supplyKeeper supply.Keeper + stakingKeeper staking.Keeper + slashingKeeper slashing.Keeper + mintKeeper mint.Keeper + distrKeeper distr.Keeper + govKeeper gov.Keeper + crisisKeeper crisis.Keeper + paramsKeeper params.Keeper // the module manager mm *module.Manager @@ -113,21 +115,21 @@ func NewSimApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bo bApp.SetAppVersion(version.Version) var app = &SimApp{ - BaseApp: bApp, - cdc: cdc, - invCheckPeriod: invCheckPeriod, - keyMain: sdk.NewKVStoreKey(bam.MainStoreKey), - keyAccount: sdk.NewKVStoreKey(auth.StoreKey), - keyStaking: sdk.NewKVStoreKey(staking.StoreKey), - tkeyStaking: sdk.NewTransientStoreKey(staking.TStoreKey), - keyMint: sdk.NewKVStoreKey(mint.StoreKey), - keyDistr: sdk.NewKVStoreKey(distr.StoreKey), - tkeyDistr: sdk.NewTransientStoreKey(distr.TStoreKey), - keySlashing: sdk.NewKVStoreKey(slashing.StoreKey), - keyGov: sdk.NewKVStoreKey(gov.StoreKey), - keyFeeCollection: sdk.NewKVStoreKey(auth.FeeStoreKey), - keyParams: sdk.NewKVStoreKey(params.StoreKey), - tkeyParams: sdk.NewTransientStoreKey(params.TStoreKey), + BaseApp: bApp, + cdc: cdc, + invCheckPeriod: invCheckPeriod, + keyMain: sdk.NewKVStoreKey(bam.MainStoreKey), + keyAccount: sdk.NewKVStoreKey(auth.StoreKey), + keyStaking: sdk.NewKVStoreKey(staking.StoreKey), + keySupply: sdk.NewKVStoreKey(supply.StoreKey), + tkeyStaking: sdk.NewTransientStoreKey(staking.TStoreKey), + keyMint: sdk.NewKVStoreKey(mint.StoreKey), + keyDistr: sdk.NewKVStoreKey(distr.StoreKey), + tkeyDistr: sdk.NewTransientStoreKey(distr.TStoreKey), + keySlashing: sdk.NewKVStoreKey(slashing.StoreKey), + keyGov: sdk.NewKVStoreKey(gov.StoreKey), + keyParams: sdk.NewKVStoreKey(params.StoreKey), + tkeyParams: sdk.NewTransientStoreKey(params.TStoreKey), } // init params keeper and subspaces @@ -141,19 +143,24 @@ func NewSimApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bo govSubspace := app.paramsKeeper.Subspace(gov.DefaultParamspace) crisisSubspace := app.paramsKeeper.Subspace(crisis.DefaultParamspace) + // account permissions + basicModuleAccs := []string{auth.FeeCollectorName, distr.ModuleName} + minterModuleAccs := []string{mint.ModuleName} + burnerModuleAccs := []string{staking.BondedPoolName, staking.NotBondedPoolName, gov.ModuleName} + // add keepers app.accountKeeper = auth.NewAccountKeeper(app.cdc, app.keyAccount, authSubspace, auth.ProtoBaseAccount) app.bankKeeper = bank.NewBaseKeeper(app.accountKeeper, bankSubspace, bank.DefaultCodespace) - app.feeCollectionKeeper = auth.NewFeeCollectionKeeper(app.cdc, app.keyFeeCollection) - stakingKeeper := staking.NewKeeper(app.cdc, app.keyStaking, app.tkeyStaking, app.bankKeeper, - stakingSubspace, staking.DefaultCodespace) - app.mintKeeper = mint.NewKeeper(app.cdc, app.keyMint, mintSubspace, &stakingKeeper, app.feeCollectionKeeper) - app.distrKeeper = distr.NewKeeper(app.cdc, app.keyDistr, distrSubspace, app.bankKeeper, &stakingKeeper, - app.feeCollectionKeeper, distr.DefaultCodespace) + app.supplyKeeper = supply.NewKeeper(app.cdc, app.keySupply, app.accountKeeper, + app.bankKeeper, supply.DefaultCodespace, basicModuleAccs, minterModuleAccs, burnerModuleAccs) + stakingKeeper := staking.NewKeeper(app.cdc, app.keyStaking, app.tkeyStaking, + app.supplyKeeper, stakingSubspace, staking.DefaultCodespace) + app.mintKeeper = mint.NewKeeper(app.cdc, app.keyMint, mintSubspace, &stakingKeeper, app.supplyKeeper, auth.FeeCollectorName) + app.distrKeeper = distr.NewKeeper(app.cdc, app.keyDistr, distrSubspace, &stakingKeeper, + app.supplyKeeper, distr.DefaultCodespace, auth.FeeCollectorName) app.slashingKeeper = slashing.NewKeeper(app.cdc, app.keySlashing, &stakingKeeper, slashingSubspace, slashing.DefaultCodespace) - app.crisisKeeper = crisis.NewKeeper(crisisSubspace, invCheckPeriod, app.distrKeeper, - app.bankKeeper, app.feeCollectionKeeper) + app.crisisKeeper = crisis.NewKeeper(crisisSubspace, invCheckPeriod, app.supplyKeeper, auth.FeeCollectorName) // register the proposal types govRouter := gov.NewRouter() @@ -161,7 +168,7 @@ func NewSimApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bo AddRoute(params.RouterKey, params.NewParamChangeProposalHandler(app.paramsKeeper)). AddRoute(distr.RouterKey, distr.NewCommunityPoolSpendProposalHandler(app.distrKeeper)) app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.paramsKeeper, govSubspace, - app.bankKeeper, &stakingKeeper, gov.DefaultCodespace, govRouter) + app.supplyKeeper, &stakingKeeper, gov.DefaultCodespace, govRouter) // register the staking hooks // NOTE: stakingKeeper above is passed by reference, so that it will contain these hooks @@ -171,14 +178,15 @@ func NewSimApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bo app.mm = module.NewManager( genaccounts.NewAppModule(app.accountKeeper), genutil.NewAppModule(app.accountKeeper, app.stakingKeeper, app.BaseApp.DeliverTx), - auth.NewAppModule(app.accountKeeper, app.feeCollectionKeeper), + auth.NewAppModule(app.accountKeeper), bank.NewAppModule(app.bankKeeper, app.accountKeeper), crisis.NewAppModule(app.crisisKeeper), - distr.NewAppModule(app.distrKeeper), - gov.NewAppModule(app.govKeeper), + supply.NewAppModule(app.supplyKeeper, app.accountKeeper), + distr.NewAppModule(app.distrKeeper, app.supplyKeeper), + gov.NewAppModule(app.govKeeper, app.supplyKeeper), mint.NewAppModule(app.mintKeeper), slashing.NewAppModule(app.slashingKeeper, app.stakingKeeper), - staking.NewAppModule(app.stakingKeeper, app.feeCollectionKeeper, app.distrKeeper, app.accountKeeper), + staking.NewAppModule(app.stakingKeeper, app.distrKeeper, app.accountKeeper, app.supplyKeeper), ) // During begin block slashing happens after distr.BeginBlocker so that @@ -190,7 +198,7 @@ func NewSimApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bo // genutils must occur after staking so that pools are properly // initialized with tokens from genesis accounts. - app.mm.SetOrderInitGenesis(genaccounts.ModuleName, distr.ModuleName, + app.mm.SetOrderInitGenesis(genaccounts.ModuleName, supply.ModuleName, distr.ModuleName, staking.ModuleName, auth.ModuleName, bank.ModuleName, slashing.ModuleName, gov.ModuleName, mint.ModuleName, crisis.ModuleName, genutil.ModuleName) @@ -198,14 +206,14 @@ func NewSimApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bo app.mm.RegisterRoutes(app.Router(), app.QueryRouter()) // initialize stores - app.MountStores(app.keyMain, app.keyAccount, app.keyStaking, app.keyMint, - app.keyDistr, app.keySlashing, app.keyGov, app.keyFeeCollection, - app.keyParams, app.tkeyParams, app.tkeyStaking, app.tkeyDistr) + app.MountStores(app.keyMain, app.keyAccount, app.keySupply, app.keyStaking, + app.keyMint, app.keyDistr, app.keySlashing, app.keyGov, app.keyParams, + app.tkeyParams, app.tkeyStaking, app.tkeyDistr) // initialize BaseApp app.SetInitChainer(app.InitChainer) app.SetBeginBlocker(app.BeginBlocker) - app.SetAnteHandler(auth.NewAnteHandler(app.accountKeeper, app.feeCollectionKeeper, auth.DefaultSigVerificationGasConsumer)) + app.SetAnteHandler(auth.NewAnteHandler(app.accountKeeper, app.supplyKeeper, auth.DefaultSigVerificationGasConsumer)) app.SetEndBlocker(app.EndBlocker) if loadLatest { diff --git a/simapp/sim_test.go b/simapp/sim_test.go index eedbac68b..808e07bd5 100644 --- a/simapp/sim_test.go +++ b/simapp/sim_test.go @@ -23,11 +23,11 @@ import ( "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/cosmos/cosmos-sdk/x/auth/genaccounts" authsim "github.com/cosmos/cosmos-sdk/x/auth/simulation" "github.com/cosmos/cosmos-sdk/x/bank" distr "github.com/cosmos/cosmos-sdk/x/distribution" distrsim "github.com/cosmos/cosmos-sdk/x/distribution/simulation" + "github.com/cosmos/cosmos-sdk/x/genaccounts" "github.com/cosmos/cosmos-sdk/x/gov" govsim "github.com/cosmos/cosmos-sdk/x/gov/simulation" "github.com/cosmos/cosmos-sdk/x/mint" @@ -37,6 +37,7 @@ import ( slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation" "github.com/cosmos/cosmos-sdk/x/staking" stakingsim "github.com/cosmos/cosmos-sdk/x/staking/simulation" + "github.com/cosmos/cosmos-sdk/x/supply" ) var ( @@ -145,6 +146,7 @@ func appStateRandomizedFn( genGenesisAccounts(cdc, r, accs, genesisTimestamp, amount, numInitiallyBonded, genesisState) genAuthGenesisState(cdc, r, appParams, genesisState) genBankGenesisState(cdc, r, appParams, genesisState) + genSupplyGenesisState(cdc, amount, numInitiallyBonded, int64(len(accs)), genesisState) genGovGenesisState(cdc, r, appParams, genesisState) genMintGenesisState(cdc, r, appParams, genesisState) genDistrGenesisState(cdc, r, appParams, genesisState) @@ -192,7 +194,6 @@ func appStateFn( func genAuthGenesisState(cdc *codec.Codec, r *rand.Rand, ap simulation.AppParams, genesisState map[string]json.RawMessage) { authGenesis := auth.NewGenesisState( - nil, auth.NewParams( func(r *rand.Rand) uint64 { var v uint64 @@ -257,6 +258,16 @@ func genBankGenesisState(cdc *codec.Codec, r *rand.Rand, ap simulation.AppParams genesisState[bank.ModuleName] = cdc.MustMarshalJSON(bankGenesis) } +func genSupplyGenesisState(cdc *codec.Codec, amount, numInitiallyBonded, numAccs int64, genesisState map[string]json.RawMessage) { + totalSupply := sdk.NewInt(amount * (numAccs + numInitiallyBonded)) + supplyGenesis := supply.NewGenesisState( + supply.NewSupply(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, totalSupply))), + ) + + fmt.Printf("Generated supply parameters:\n%s\n", codec.MustMarshalJSONIndent(cdc, supplyGenesis)) + genesisState[supply.ModuleName] = cdc.MustMarshalJSON(supplyGenesis) +} + func genGenesisAccounts( cdc *codec.Codec, r *rand.Rand, accs []simulation.Account, genesisTimestamp time.Time, amount, numInitiallyBonded int64, @@ -517,7 +528,6 @@ func genStakingGenesisState( ) staking.GenesisState { stakingGenesis := staking.NewGenesisState( - staking.InitialPool(), staking.NewParams( func(r *rand.Rand) time.Duration { var v time.Duration @@ -560,7 +570,6 @@ func genStakingGenesisState( delegations = append(delegations, delegation) } - stakingGenesis.Pool.NotBondedTokens = sdk.NewInt((amount * numAccs) + (numInitiallyBonded * amount)) stakingGenesis.Validators = validators stakingGenesis.Delegations = delegations @@ -593,7 +602,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation { }) return v }(nil), - authsim.SimulateDeductFee(app.accountKeeper, app.feeCollectionKeeper), + authsim.SimulateDeductFee(app.accountKeeper, app.supplyKeeper), }, { func(_ *rand.Rand) int { @@ -764,6 +773,11 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation { } func invariants(app *SimApp) []sdk.Invariant { + // TODO: fix PeriodicInvariants, it doesn't seem to call individual invariants for a period of 1 + // Ref: https://github.com/cosmos/cosmos-sdk/issues/4631 + if period == 1 { + return app.crisisKeeper.Invariants() + } return simulation.PeriodicInvariants(app.crisisKeeper.Invariants(), period, 0) } @@ -896,6 +910,7 @@ func TestAppImportExport(t *testing.T) { if err != nil { panic(err) } + fmt.Printf("debug genesisState: %s\n", genesisState) ctxB := newApp.NewContext(true, abci.Header{}) newApp.mm.InitGenesis(ctxB, genesisState) @@ -917,7 +932,7 @@ func TestAppImportExport(t *testing.T) { {app.keySlashing, newApp.keySlashing, [][]byte{}}, {app.keyMint, newApp.keyMint, [][]byte{}}, {app.keyDistr, newApp.keyDistr, [][]byte{}}, - {app.keyFeeCollection, newApp.keyFeeCollection, [][]byte{}}, + {app.keySupply, newApp.keySupply, [][]byte{}}, {app.keyParams, newApp.keyParams, [][]byte{}}, {app.keyGov, newApp.keyGov, [][]byte{}}, } @@ -1074,7 +1089,7 @@ func BenchmarkInvariants(b *testing.B) { for _, cr := range app.crisisKeeper.Routes() { b.Run(fmt.Sprintf("%s/%s", cr.ModuleName, cr.Route), func(b *testing.B) { if err := cr.Invar(ctx); err != nil { - fmt.Println(err) + fmt.Printf("broken invariant at block %d of %d\n%s", ctx.BlockHeight()-1, numBlocks, err) b.FailNow() } }) diff --git a/simapp/utils.go b/simapp/utils.go index 2c97b5343..415520909 100644 --- a/simapp/utils.go +++ b/simapp/utils.go @@ -22,6 +22,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/slashing" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" ) // NewSimAppUNSAFE is used for debugging purposes only. @@ -57,6 +58,8 @@ func getSimulationLog(storeName string, cdcA, cdcB *codec.Codec, kvA, kvB cmn.KV return decodeGovStore(cdcA, cdcB, kvA, kvB) case distribution.StoreKey: return decodeDistributionStore(cdcA, cdcB, kvA, kvB) + case supply.StoreKey: + return decodeSupplyStore(cdcA, cdcB, kvA, kvB) default: return } @@ -254,3 +257,15 @@ func decodeGovStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string { panic(fmt.Sprintf("invalid governance key prefix %X", kvA.Key[:1])) } } + +func decodeSupplyStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string { + switch { + case bytes.Equal(kvA.Key[:1], supply.SupplyKey): + var supplyA, supplyB supply.Supply + cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &supplyA) + cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &supplyB) + return fmt.Sprintf("%v\n%v", supplyB, supplyB) + default: + panic(fmt.Sprintf("invalid supply key %X", kvA.Key)) + } +} diff --git a/simapp/utils_test.go b/simapp/utils_test.go index f03691f2c..8cea79ab7 100644 --- a/simapp/utils_test.go +++ b/simapp/utils_test.go @@ -20,6 +20,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/slashing" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -55,6 +56,7 @@ func TestGetSimulationLog(t *testing.T) { {gov.StoreKey, cmn.KVPair{Key: gov.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(gov.Vote{})}}, {distribution.StoreKey, cmn.KVPair{Key: distr.ProposerKey, Value: consAddr1.Bytes()}}, {slashing.StoreKey, cmn.KVPair{Key: slashing.GetValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryLengthPrefixed(true)}}, + {supply.StoreKey, cmn.KVPair{Key: supply.SupplyKey, Value: cdc.MustMarshalBinaryLengthPrefixed(supply.NewSupply(sdk.Coins{}))}}, {"Empty", cmn.KVPair{}}, {"OtherStore", cmn.KVPair{Key: []byte("key"), Value: []byte("value")}}, } @@ -183,14 +185,12 @@ func TestDecodeStakingStore(t *testing.T) { bondTime := time.Now().UTC() - pool := staking.InitialPool() val := staking.NewValidator(valAddr1, delPk1, staking.NewDescription("test", "test", "test", "test")) del := staking.NewDelegation(delAddr1, valAddr1, sdk.OneDec()) ubd := staking.NewUnbondingDelegation(delAddr1, valAddr1, 15, bondTime, sdk.OneInt()) red := staking.NewRedelegation(delAddr1, valAddr1, valAddr1, 12, bondTime, sdk.OneInt(), sdk.OneDec()) kvPairs := cmn.KVPairs{ - cmn.KVPair{Key: staking.PoolKey, Value: cdc.MustMarshalBinaryLengthPrefixed(pool)}, cmn.KVPair{Key: staking.LastTotalPowerKey, Value: cdc.MustMarshalBinaryLengthPrefixed(sdk.OneInt())}, cmn.KVPair{Key: staking.GetValidatorKey(valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(val)}, cmn.KVPair{Key: staking.LastValidatorPowerKey, Value: valAddr1.Bytes()}, @@ -204,7 +204,6 @@ func TestDecodeStakingStore(t *testing.T) { name string expectedLog string }{ - {"Pool", fmt.Sprintf("%v\n%v", pool, pool)}, {"LastTotalPower", fmt.Sprintf("%v\n%v", sdk.OneInt(), sdk.OneInt())}, {"Validator", fmt.Sprintf("%v\n%v", val, val)}, {"LastValidatorPower/ValidatorsByConsAddr/ValidatorsByPowerIndex", fmt.Sprintf("%v\n%v", valAddr1, valAddr1)}, @@ -302,3 +301,33 @@ func TestDecodeGovStore(t *testing.T) { }) } } + +func TestDecodeSupplyStore(t *testing.T) { + cdc := makeTestCodec() + + totalSupply := supply.NewSupply(sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000))) + + kvPairs := cmn.KVPairs{ + cmn.KVPair{Key: supply.SupplyKey, Value: cdc.MustMarshalBinaryLengthPrefixed(totalSupply)}, + cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}}, + } + + tests := []struct { + name string + expectedLog string + }{ + {"Supply", fmt.Sprintf("%v\n%v", totalSupply, totalSupply)}, + {"other", ""}, + } + + for i, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + switch i { + case len(tests) - 1: + require.Panics(t, func() { decodeSupplyStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name) + default: + require.Equal(t, tt.expectedLog, decodeSupplyStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name) + } + }) + } +} diff --git a/x/auth/alias.go b/x/auth/alias.go index 450bd862e..2f129ea30 100644 --- a/x/auth/alias.go +++ b/x/auth/alias.go @@ -12,7 +12,7 @@ import ( const ( ModuleName = types.ModuleName StoreKey = types.StoreKey - FeeStoreKey = types.FeeStoreKey + FeeCollectorName = types.FeeCollectorName QuerierRoute = types.QuerierRoute DefaultParamspace = types.DefaultParamspace DefaultMaxMemoCharacters = types.DefaultMaxMemoCharacters @@ -34,8 +34,6 @@ var ( NewDelayedVestingAccountRaw = types.NewDelayedVestingAccountRaw NewDelayedVestingAccount = types.NewDelayedVestingAccount RegisterCodec = types.RegisterCodec - RegisterBaseAccount = types.RegisterBaseAccount - NewFeeCollectionKeeper = types.NewFeeCollectionKeeper NewGenesisState = types.NewGenesisState DefaultGenesisState = types.DefaultGenesisState ValidateGenesis = types.ValidateGenesis @@ -43,6 +41,7 @@ var ( NewParams = types.NewParams ParamKeyTable = types.ParamKeyTable DefaultParams = types.DefaultParams + NewQueryAccountParams = types.NewQueryAccountParams NewStdTx = types.NewStdTx CountSubKeys = types.CountSubKeys NewStdFee = types.NewStdFee @@ -72,9 +71,9 @@ type ( BaseVestingAccount = types.BaseVestingAccount ContinuousVestingAccount = types.ContinuousVestingAccount DelayedVestingAccount = types.DelayedVestingAccount - FeeCollectionKeeper = types.FeeCollectionKeeper GenesisState = types.GenesisState Params = types.Params + QueryAccountParams = types.QueryAccountParams StdSignMsg = types.StdSignMsg StdTx = types.StdTx StdFee = types.StdFee diff --git a/x/auth/ante.go b/x/auth/ante.go index 28a16821e..9387b07ec 100644 --- a/x/auth/ante.go +++ b/x/auth/ante.go @@ -4,7 +4,6 @@ import ( "bytes" "encoding/hex" "fmt" - "time" "github.com/tendermint/tendermint/crypto/ed25519" @@ -14,6 +13,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth/types" ) var ( @@ -35,11 +35,15 @@ type SignatureVerificationGasConsumer = func(meter sdk.GasMeter, sig []byte, pub // NewAnteHandler returns an AnteHandler that checks and increments sequence // numbers, checks signatures & account numbers, and deducts fees from the first // signer. -func NewAnteHandler(ak AccountKeeper, fck FeeCollectionKeeper, sigGasConsumer SignatureVerificationGasConsumer) sdk.AnteHandler { +func NewAnteHandler(ak AccountKeeper, supplyKeeper types.SupplyKeeper, sigGasConsumer SignatureVerificationGasConsumer) sdk.AnteHandler { return func( ctx sdk.Context, tx sdk.Tx, simulate bool, ) (newCtx sdk.Context, res sdk.Result, abort bool) { + if addr := supplyKeeper.GetModuleAddress(types.FeeCollectorName); addr == nil { + panic(fmt.Sprintf("%s module account has not been set", types.FeeCollectorName)) + } + // all transactions must be of type auth.StdTx stdTx, ok := tx.(StdTx) if !ok { @@ -112,13 +116,15 @@ func NewAnteHandler(ak AccountKeeper, fck FeeCollectionKeeper, sigGasConsumer Si return newCtx, res, true } + // deduct the fees if !stdTx.Fee.Amount.IsZero() { - signerAccs[0], res = DeductFees(ctx.BlockHeader().Time, signerAccs[0], stdTx.Fee) + res = DeductFees(supplyKeeper, newCtx, signerAccs[0], stdTx.Fee.Amount) if !res.IsOK() { return newCtx, res, true } - fck.AddCollectedFees(newCtx, stdTx.Fee.Amount) + // reload the account as fees have been deducted + signerAccs[0] = ak.GetAccount(newCtx, signerAccs[0].GetAddress()) } // stdSigs contains the sequence number, account number, and signatures. @@ -327,36 +333,37 @@ func consumeMultisignatureVerificationGas(meter sdk.GasMeter, // // NOTE: We could use the CoinKeeper (in addition to the AccountKeeper, because // the CoinKeeper doesn't give us accounts), but it seems easier to do this. -func DeductFees(blockTime time.Time, acc Account, fee StdFee) (Account, sdk.Result) { +func DeductFees(supplyKeeper types.SupplyKeeper, ctx sdk.Context, acc Account, fees sdk.Coins) sdk.Result { + blockTime := ctx.BlockHeader().Time coins := acc.GetCoins() - feeAmount := fee.Amount - if !feeAmount.IsValid() { - return nil, sdk.ErrInsufficientFee(fmt.Sprintf("invalid fee amount: %s", feeAmount)).Result() + if !fees.IsValid() { + return sdk.ErrInsufficientFee(fmt.Sprintf("invalid fee amount: %s", fees)).Result() } - // get the resulting coins deducting the fees - newCoins, ok := coins.SafeSub(feeAmount) - if ok { - return nil, sdk.ErrInsufficientFunds( - fmt.Sprintf("insufficient funds to pay for fees; %s < %s", coins, feeAmount), + // verify the account has enough funds to pay for fees + _, hasNeg := coins.SafeSub(fees) + if hasNeg { + return sdk.ErrInsufficientFunds( + fmt.Sprintf("insufficient funds to pay for fees; %s < %s", coins, fees), ).Result() } // Validate the account has enough "spendable" coins as this will cover cases // such as vesting accounts. spendableCoins := acc.SpendableCoins(blockTime) - if _, hasNeg := spendableCoins.SafeSub(feeAmount); hasNeg { - return nil, sdk.ErrInsufficientFunds( - fmt.Sprintf("insufficient funds to pay for fees; %s < %s", spendableCoins, feeAmount), + if _, hasNeg := spendableCoins.SafeSub(fees); hasNeg { + return sdk.ErrInsufficientFunds( + fmt.Sprintf("insufficient funds to pay for fees; %s < %s", spendableCoins, fees), ).Result() } - if err := acc.SetCoins(newCoins); err != nil { - return nil, sdk.ErrInternal(err.Error()).Result() + err := supplyKeeper.SendCoinsFromAccountToModule(ctx, acc.GetAddress(), types.FeeCollectorName, fees) + if err != nil { + return err.Result() } - return acc, sdk.Result{} + return sdk.Result{} } // EnsureSufficientMempoolFees verifies that the given transaction has supplied diff --git a/x/auth/ante_test.go b/x/auth/ante_test.go index 3f0350c42..4faae8ea9 100644 --- a/x/auth/ante_test.go +++ b/x/auth/ante_test.go @@ -19,6 +19,7 @@ import ( // run the tx through the anteHandler and ensure its valid func checkValidTx(t *testing.T, anteHandler sdk.AnteHandler, ctx sdk.Context, tx sdk.Tx, simulate bool) { _, result, abort := anteHandler(ctx, tx, simulate) + require.Equal(t, "", result.Log) require.False(t, abort) require.Equal(t, sdk.CodeOK, result.Code) require.True(t, result.IsOK()) @@ -48,7 +49,7 @@ func TestAnteHandlerSigErrors(t *testing.T) { // setup input := setupTestInput() ctx := input.ctx - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) // keys and addresses priv1, _, addr1 := types.KeyTestPubAddr() @@ -96,7 +97,7 @@ func TestAnteHandlerSigErrors(t *testing.T) { func TestAnteHandlerAccountNumbers(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -106,9 +107,11 @@ func TestAnteHandlerAccountNumbers(t *testing.T) { // set the accounts acc1 := input.ak.NewAccountWithAddress(ctx, addr1) acc1.SetCoins(types.NewTestCoins()) + require.NoError(t, acc1.SetAccountNumber(0)) input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) // msg and signatures @@ -151,19 +154,20 @@ func TestAnteHandlerAccountNumbers(t *testing.T) { func TestAnteHandlerAccountNumbersAtBlockHeightZero(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(0) // keys and addresses priv1, _, addr1 := types.KeyTestPubAddr() priv2, _, addr2 := types.KeyTestPubAddr() - // set the accounts + // set the accounts, we don't need the acc numbers as it is in the genesis block acc1 := input.ak.NewAccountWithAddress(ctx, addr1) acc1.SetCoins(types.NewTestCoins()) input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) // msg and signatures @@ -206,7 +210,7 @@ func TestAnteHandlerAccountNumbersAtBlockHeightZero(t *testing.T) { func TestAnteHandlerSequences(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -217,12 +221,15 @@ func TestAnteHandlerSequences(t *testing.T) { // set the accounts acc1 := input.ak.NewAccountWithAddress(ctx, addr1) acc1.SetCoins(types.NewTestCoins()) + require.NoError(t, acc1.SetAccountNumber(0)) input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) acc3 := input.ak.NewAccountWithAddress(ctx, addr3) acc3.SetCoins(types.NewTestCoins()) + require.NoError(t, acc3.SetAccountNumber(2)) input.ak.SetAccount(ctx, acc3) // msg and signatures @@ -281,7 +288,7 @@ func TestAnteHandlerFees(t *testing.T) { // setup input := setupTestInput() ctx := input.ctx - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) // keys and addresses priv1, _, addr1 := types.KeyTestPubAddr() @@ -305,23 +312,22 @@ func TestAnteHandlerFees(t *testing.T) { input.ak.SetAccount(ctx, acc1) checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeInsufficientFunds) - emptyCoins := sdk.NewCoins() - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(emptyCoins)) - require.True(t, input.ak.GetAccount(ctx, addr1).GetCoins().AmountOf("atom").Equal(sdk.NewInt(149))) + require.True(t, input.sk.GetModuleAccount(ctx, types.FeeCollectorName).GetCoins().Empty()) + require.True(sdk.IntEq(t, input.ak.GetAccount(ctx, addr1).GetCoins().AmountOf("atom"), sdk.NewInt(149))) acc1.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("atom", 150))) input.ak.SetAccount(ctx, acc1) checkValidTx(t, anteHandler, ctx, tx, false) - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("atom", 150)))) - require.True(t, input.ak.GetAccount(ctx, addr1).GetCoins().AmountOf("atom").Equal(sdk.NewInt(0))) + require.True(sdk.IntEq(t, input.sk.GetModuleAccount(ctx, types.FeeCollectorName).GetCoins().AmountOf("atom"), sdk.NewInt(150))) + require.True(sdk.IntEq(t, input.ak.GetAccount(ctx, addr1).GetCoins().AmountOf("atom"), sdk.NewInt(0))) } // Test logic around memo gas consumption. func TestAnteHandlerMemoGas(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -329,6 +335,7 @@ func TestAnteHandlerMemoGas(t *testing.T) { // set the accounts acc1 := input.ak.NewAccountWithAddress(ctx, addr1) + require.NoError(t, acc1.SetAccountNumber(0)) input.ak.SetAccount(ctx, acc1) // msg and signatures @@ -360,7 +367,7 @@ func TestAnteHandlerMemoGas(t *testing.T) { func TestAnteHandlerMultiSigner(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -371,12 +378,15 @@ func TestAnteHandlerMultiSigner(t *testing.T) { // set the accounts acc1 := input.ak.NewAccountWithAddress(ctx, addr1) acc1.SetCoins(types.NewTestCoins()) + require.NoError(t, acc1.SetAccountNumber(0)) input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) acc3 := input.ak.NewAccountWithAddress(ctx, addr3) acc3.SetCoins(types.NewTestCoins()) + require.NoError(t, acc3.SetAccountNumber(2)) input.ak.SetAccount(ctx, acc3) // set up msgs and fee @@ -407,7 +417,7 @@ func TestAnteHandlerMultiSigner(t *testing.T) { func TestAnteHandlerBadSignBytes(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -417,9 +427,11 @@ func TestAnteHandlerBadSignBytes(t *testing.T) { // set the accounts acc1 := input.ak.NewAccountWithAddress(ctx, addr1) acc1.SetCoins(types.NewTestCoins()) + require.NoError(t, acc1.SetAccountNumber(0)) input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) var tx sdk.Tx @@ -482,7 +494,7 @@ func TestAnteHandlerBadSignBytes(t *testing.T) { func TestAnteHandlerSetPubKey(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -492,9 +504,11 @@ func TestAnteHandlerSetPubKey(t *testing.T) { // set the accounts acc1 := input.ak.NewAccountWithAddress(ctx, addr1) acc1.SetCoins(types.NewTestCoins()) + require.NoError(t, acc1.SetAccountNumber(0)) input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) var tx sdk.Tx @@ -676,7 +690,7 @@ func TestCountSubkeys(t *testing.T) { func TestAnteHandlerSigLimitExceeded(t *testing.T) { // setup input := setupTestInput() - anteHandler := NewAnteHandler(input.ak, input.fck, DefaultSigVerificationGasConsumer) + anteHandler := NewAnteHandler(input.ak, input.sk, DefaultSigVerificationGasConsumer) ctx := input.ctx.WithBlockHeight(1) // keys and addresses @@ -695,6 +709,7 @@ func TestAnteHandlerSigLimitExceeded(t *testing.T) { input.ak.SetAccount(ctx, acc1) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) acc2.SetCoins(types.NewTestCoins()) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) var tx sdk.Tx @@ -765,7 +780,7 @@ func TestCustomSignatureVerificationGasConsumer(t *testing.T) { // setup input := setupTestInput() // setup an ante handler that only accepts PubKeyEd25519 - anteHandler := NewAnteHandler(input.ak, input.fck, func(meter sdk.GasMeter, sig []byte, pubkey crypto.PubKey, params Params) sdk.Result { + anteHandler := NewAnteHandler(input.ak, input.sk, func(meter sdk.GasMeter, sig []byte, pubkey crypto.PubKey, params Params) sdk.Result { switch pubkey := pubkey.(type) { case ed25519.PubKeyEd25519: meter.ConsumeGas(params.SigVerifyCostED25519, "ante verify: ed25519") @@ -781,6 +796,7 @@ func TestCustomSignatureVerificationGasConsumer(t *testing.T) { acc1 := input.ak.NewAccountWithAddress(ctx, addr1) _ = acc1.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("atom", 150))) input.ak.SetAccount(ctx, acc1) + var tx sdk.Tx msg := types.NewTestMsg(addr1) privs, accnums, seqs := []crypto.PrivKey{priv1}, []uint64{0}, []uint64{0} @@ -794,7 +810,8 @@ func TestCustomSignatureVerificationGasConsumer(t *testing.T) { pub2 := priv2.PubKey() addr2 := sdk.AccAddress(pub2.Address()) acc2 := input.ak.NewAccountWithAddress(ctx, addr2) - _ = acc2.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("atom", 150))) + require.NoError(t, acc2.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("atom", 150)))) + require.NoError(t, acc2.SetAccountNumber(1)) input.ak.SetAccount(ctx, acc2) msg = types.NewTestMsg(addr2) privs, accnums, seqs = []crypto.PrivKey{priv2}, []uint64{1}, []uint64{0} diff --git a/x/auth/genesis.go b/x/auth/genesis.go index 5ba1dda09..6f4931b13 100644 --- a/x/auth/genesis.go +++ b/x/auth/genesis.go @@ -2,19 +2,18 @@ package auth import ( sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth/types" ) // InitGenesis - Init store state from genesis data -func InitGenesis(ctx sdk.Context, ak AccountKeeper, fck types.FeeCollectionKeeper, data types.GenesisState) { +// +// CONTRACT: old coins from the FeeCollectionKeeper need to be transferred through +// a genesis port script to the new fee collector account +func InitGenesis(ctx sdk.Context, ak AccountKeeper, data GenesisState) { ak.SetParams(ctx, data.Params) - fck.AddCollectedFees(ctx, data.CollectedFees) } // ExportGenesis returns a GenesisState for a given context and keeper -func ExportGenesis(ctx sdk.Context, ak AccountKeeper, fck types.FeeCollectionKeeper) types.GenesisState { - collectedFees := fck.GetCollectedFees(ctx) +func ExportGenesis(ctx sdk.Context, ak AccountKeeper) GenesisState { params := ak.GetParams(ctx) - - return types.NewGenesisState(collectedFees, params) + return NewGenesisState(params) } diff --git a/x/auth/module.go b/x/auth/module.go index a5852e262..ef978e020 100644 --- a/x/auth/module.go +++ b/x/auth/module.go @@ -68,17 +68,14 @@ func (AppModuleBasic) GetQueryCmd(cdc *codec.Codec) *cobra.Command { // app module object type AppModule struct { AppModuleBasic - accountKeeper AccountKeeper - feeCollectionKeeper types.FeeCollectionKeeper + accountKeeper AccountKeeper } // NewAppModule creates a new AppModule object -func NewAppModule(accountKeeper AccountKeeper, - feeCollectionKeeper types.FeeCollectionKeeper) AppModule { +func NewAppModule(accountKeeper AccountKeeper) AppModule { return AppModule{ - AppModuleBasic: AppModuleBasic{}, - accountKeeper: accountKeeper, - feeCollectionKeeper: feeCollectionKeeper, + AppModuleBasic: AppModuleBasic{}, + accountKeeper: accountKeeper, } } @@ -108,15 +105,15 @@ func (am AppModule) NewQuerierHandler() sdk.Querier { // module init-genesis func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.ValidatorUpdate { - var genesisState types.GenesisState + var genesisState GenesisState types.ModuleCdc.MustUnmarshalJSON(data, &genesisState) - InitGenesis(ctx, am.accountKeeper, am.feeCollectionKeeper, genesisState) + InitGenesis(ctx, am.accountKeeper, genesisState) return []abci.ValidatorUpdate{} } // module export genesis func (am AppModule) ExportGenesis(ctx sdk.Context) json.RawMessage { - gs := ExportGenesis(ctx, am.accountKeeper, am.feeCollectionKeeper) + gs := ExportGenesis(ctx, am.accountKeeper) return types.ModuleCdc.MustMarshalJSON(gs) } diff --git a/x/auth/simulation/fake.go b/x/auth/simulation/fake.go index b1b76f2dc..18e528f7b 100644 --- a/x/auth/simulation/fake.go +++ b/x/auth/simulation/fake.go @@ -2,25 +2,32 @@ package simulation import ( "errors" + "fmt" "math/big" "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/auth/types" "github.com/cosmos/cosmos-sdk/x/simulation" ) // SimulateDeductFee -func SimulateDeductFee(m auth.AccountKeeper, f auth.FeeCollectionKeeper) simulation.Operation { +func SimulateDeductFee(ak auth.AccountKeeper, supplyKeeper types.SupplyKeeper) simulation.Operation { return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) ( opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) { account := simulation.RandomAcc(r, accs) - stored := m.GetAccount(ctx, account.Address) + stored := ak.GetAccount(ctx, account.Address) initCoins := stored.GetCoins() - opMsg = simulation.NewOperationMsgBasic(auth.ModuleName, "deduct_fee", "", false, nil) + opMsg = simulation.NewOperationMsgBasic(types.ModuleName, "deduct_fee", "", false, nil) + + feeCollector := ak.GetAccount(ctx, supplyKeeper.GetModuleAddress(types.FeeCollectorName)) + if feeCollector == nil { + panic(fmt.Errorf("fee collector account hasn't been set")) + } if len(initCoins) == 0 { return opMsg, nil, nil @@ -36,25 +43,23 @@ func SimulateDeductFee(m auth.AccountKeeper, f auth.FeeCollectionKeeper) simulat // Create a random fee and verify the fees are within the account's spendable // balance. - fees := sdk.Coins{sdk.NewCoin(randCoin.Denom, amt)} + fees := sdk.NewCoins(sdk.NewCoin(randCoin.Denom, amt)) spendableCoins := stored.SpendableCoins(ctx.BlockHeader().Time) if _, hasNeg := spendableCoins.SafeSub(fees); hasNeg { return opMsg, nil, nil } // get the new account balance - newCoins, hasNeg := initCoins.SafeSub(fees) + _, hasNeg := initCoins.SafeSub(fees) if hasNeg { return opMsg, nil, nil } - if err := stored.SetCoins(newCoins); err != nil { + err = supplyKeeper.SendCoinsFromAccountToModule(ctx, stored.GetAddress(), types.FeeCollectorName, fees) + if err != nil { panic(err) } - m.SetAccount(ctx, stored) - f.AddCollectedFees(ctx, fees) - opMsg.OK = true return opMsg, nil, nil } diff --git a/x/auth/test_common.go b/x/auth/test_common.go index 557cc00ec..8b7b0f790 100644 --- a/x/auth/test_common.go +++ b/x/auth/test_common.go @@ -11,39 +11,104 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/cosmos/cosmos-sdk/x/params/subspace" + "github.com/cosmos/cosmos-sdk/x/supply/exported" + supplytypes "github.com/cosmos/cosmos-sdk/x/supply/types" ) type testInput struct { cdc *codec.Codec ctx sdk.Context ak AccountKeeper - fck types.FeeCollectionKeeper + sk types.SupplyKeeper } func setupTestInput() testInput { db := dbm.NewMemDB() cdc := codec.New() - types.RegisterBaseAccount(cdc) + types.RegisterCodec(cdc) + supplytypes.RegisterCodec(cdc) + codec.RegisterCrypto(cdc) authCapKey := sdk.NewKVStoreKey("authCapKey") - fckCapKey := sdk.NewKVStoreKey("fckCapKey") keyParams := sdk.NewKVStoreKey("subspace") tkeyParams := sdk.NewTransientStoreKey("transient_subspace") ms := store.NewCommitMultiStore(db) ms.MountStoreWithDB(authCapKey, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(fckCapKey, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) ms.LoadLatestVersion() ps := subspace.NewSubspace(cdc, keyParams, tkeyParams, types.DefaultParamspace) ak := NewAccountKeeper(cdc, authCapKey, ps, types.ProtoBaseAccount) - fck := types.NewFeeCollectionKeeper(cdc, fckCapKey) + sk := NewDummySupplyKeeper(ak) + ctx := sdk.NewContext(ms, abci.Header{ChainID: "test-chain-id"}, false, log.NewNopLogger()) ak.SetParams(ctx, types.DefaultParams()) - return testInput{cdc: cdc, ctx: ctx, ak: ak, fck: fck} + return testInput{cdc: cdc, ctx: ctx, ak: ak, sk: sk} +} + +// DummySupplyKeeper defines a supply keeper used only for testing to avoid +// circle dependencies +type DummySupplyKeeper struct { + ak AccountKeeper +} + +// NewDummySupplyKeeper creates a DummySupplyKeeper instance +func NewDummySupplyKeeper(ak AccountKeeper) DummySupplyKeeper { + return DummySupplyKeeper{ak} +} + +// SendCoinsFromAccountToModule for the dummy supply keeper +func (sk DummySupplyKeeper) SendCoinsFromAccountToModule(ctx sdk.Context, fromAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) sdk.Error { + + fromAcc := sk.ak.GetAccount(ctx, fromAddr) + moduleAcc := sk.GetModuleAccount(ctx, recipientModule) + + newFromCoins, hasNeg := fromAcc.GetCoins().SafeSub(amt) + if hasNeg { + return sdk.ErrInsufficientCoins(fromAcc.GetCoins().String()) + } + + newToCoins := moduleAcc.GetCoins().Add(amt) + + if err := fromAcc.SetCoins(newFromCoins); err != nil { + return sdk.ErrInternal(err.Error()) + } + + if err := moduleAcc.SetCoins(newToCoins); err != nil { + return sdk.ErrInternal(err.Error()) + } + + sk.ak.SetAccount(ctx, fromAcc) + sk.ak.SetAccount(ctx, moduleAcc) + + return nil +} + +// GetModuleAccount for dummy supply keeper +func (sk DummySupplyKeeper) GetModuleAccount(ctx sdk.Context, moduleName string) exported.ModuleAccountI { + addr := sk.GetModuleAddress(moduleName) + + acc := sk.ak.GetAccount(ctx, addr) + if acc != nil { + macc, ok := acc.(exported.ModuleAccountI) + if ok { + return macc + } + } + + // create a new module account + macc := supplytypes.NewEmptyModuleAccount(moduleName, "basic") + maccI := (sk.ak.NewAccount(ctx, macc)).(exported.ModuleAccountI) + sk.ak.SetAccount(ctx, maccI) + return maccI +} + +// GetModuleAddress for dummy supply keeper +func (sk DummySupplyKeeper) GetModuleAddress(moduleName string) sdk.AccAddress { + return supplytypes.NewModuleAddress(moduleName) } diff --git a/x/auth/types/codec.go b/x/auth/types/codec.go index ce5b4c777..81a6ee894 100644 --- a/x/auth/types/codec.go +++ b/x/auth/types/codec.go @@ -8,23 +8,12 @@ import ( // RegisterCodec registers concrete types on the codec func RegisterCodec(cdc *codec.Codec) { cdc.RegisterInterface((*exported.Account)(nil), nil) + cdc.RegisterConcrete(&BaseAccount{}, "cosmos-sdk/Account", nil) cdc.RegisterInterface((*exported.VestingAccount)(nil), nil) - cdc.RegisterConcrete(&BaseAccount{}, "auth/Account", nil) - cdc.RegisterConcrete(&BaseVestingAccount{}, "auth/BaseVestingAccount", nil) - cdc.RegisterConcrete(&ContinuousVestingAccount{}, "auth/ContinuousVestingAccount", nil) - cdc.RegisterConcrete(&DelayedVestingAccount{}, "auth/DelayedVestingAccount", nil) - cdc.RegisterConcrete(StdTx{}, "auth/StdTx", nil) -} - -// RegisterBaseAccount most users shouldn't use this, but this comes in handy for tests. -func RegisterBaseAccount(cdc *codec.Codec) { - cdc.RegisterInterface((*exported.Account)(nil), nil) - cdc.RegisterInterface((*exported.VestingAccount)(nil), nil) - cdc.RegisterConcrete(&BaseAccount{}, "cosmos-sdk/BaseAccount", nil) cdc.RegisterConcrete(&BaseVestingAccount{}, "cosmos-sdk/BaseVestingAccount", nil) cdc.RegisterConcrete(&ContinuousVestingAccount{}, "cosmos-sdk/ContinuousVestingAccount", nil) cdc.RegisterConcrete(&DelayedVestingAccount{}, "cosmos-sdk/DelayedVestingAccount", nil) - codec.RegisterCrypto(cdc) + cdc.RegisterConcrete(StdTx{}, "cosmos-sdk/StdTx", nil) } // module wide codec diff --git a/x/auth/types/expected_keepers.go b/x/auth/types/expected_keepers.go new file mode 100644 index 000000000..11e03ef36 --- /dev/null +++ b/x/auth/types/expected_keepers.go @@ -0,0 +1,13 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/exported" +) + +// SupplyKeeper defines the expected supply Keeper (noalias) +type SupplyKeeper interface { + SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) sdk.Error + GetModuleAccount(ctx sdk.Context, moduleName string) exported.ModuleAccountI + GetModuleAddress(moduleName string) sdk.AccAddress +} diff --git a/x/auth/types/feekeeper.go b/x/auth/types/feekeeper.go deleted file mode 100644 index c0b37a150..000000000 --- a/x/auth/types/feekeeper.go +++ /dev/null @@ -1,62 +0,0 @@ -package types - -import ( - codec "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" -) - -var ( - collectedFeesKey = []byte("collectedFees") -) - -// FeeCollectionKeeper handles collection of fees in the anteHandler -// and setting of MinFees for different fee tokens -type FeeCollectionKeeper struct { - - // The (unexposed) key used to access the fee store from the Context. - key sdk.StoreKey - - // The codec codec for binary encoding/decoding of accounts. - cdc *codec.Codec -} - -// NewFeeCollectionKeeper returns a new FeeCollectionKeeper -func NewFeeCollectionKeeper(cdc *codec.Codec, key sdk.StoreKey) FeeCollectionKeeper { - return FeeCollectionKeeper{ - key: key, - cdc: cdc, - } -} - -// GetCollectedFees - retrieves the collected fee pool -func (fck FeeCollectionKeeper) GetCollectedFees(ctx sdk.Context) sdk.Coins { - store := ctx.KVStore(fck.key) - bz := store.Get(collectedFeesKey) - if bz == nil { - return sdk.NewCoins() - } - - emptyFees := sdk.NewCoins() - feePool := &emptyFees - fck.cdc.MustUnmarshalBinaryLengthPrefixed(bz, feePool) - return *feePool -} - -func (fck FeeCollectionKeeper) setCollectedFees(ctx sdk.Context, coins sdk.Coins) { - bz := fck.cdc.MustMarshalBinaryLengthPrefixed(coins) - store := ctx.KVStore(fck.key) - store.Set(collectedFeesKey, bz) -} - -// AddCollectedFees - add to the fee pool -func (fck FeeCollectionKeeper) AddCollectedFees(ctx sdk.Context, coins sdk.Coins) sdk.Coins { - newCoins := fck.GetCollectedFees(ctx).Add(coins) - fck.setCollectedFees(ctx, newCoins) - - return newCoins -} - -// ClearCollectedFees - clear the fee pool -func (fck FeeCollectionKeeper) ClearCollectedFees(ctx sdk.Context) { - fck.setCollectedFees(ctx, sdk.NewCoins()) -} diff --git a/x/auth/types/feekeeper_test.go b/x/auth/types/feekeeper_test.go deleted file mode 100644 index 5126aa446..000000000 --- a/x/auth/types/feekeeper_test.go +++ /dev/null @@ -1,59 +0,0 @@ -package types - -import ( - "testing" - - "github.com/stretchr/testify/require" - - sdk "github.com/cosmos/cosmos-sdk/types" -) - -var ( - emptyCoins = sdk.NewCoins() - oneCoin = sdk.NewCoins(sdk.NewInt64Coin("foocoin", 1)) - twoCoins = sdk.NewCoins(sdk.NewInt64Coin("foocoin", 2)) -) - -func TestFeeCollectionKeeperGetSet(t *testing.T) { - input := setupTestInput() - ctx := input.ctx - - // no coins initially - currFees := input.fck.GetCollectedFees(ctx) - require.True(t, currFees.IsEqual(emptyCoins)) - - // set feeCollection to oneCoin - input.fck.setCollectedFees(ctx, oneCoin) - - // check that it is equal to oneCoin - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(oneCoin)) -} - -func TestFeeCollectionKeeperAdd(t *testing.T) { - input := setupTestInput() - ctx := input.ctx - - // no coins initially - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(emptyCoins)) - - // add oneCoin and check that pool is now oneCoin - input.fck.AddCollectedFees(ctx, oneCoin) - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(oneCoin)) - - // add oneCoin again and check that pool is now twoCoins - input.fck.AddCollectedFees(ctx, oneCoin) - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(twoCoins)) -} - -func TestFeeCollectionKeeperClear(t *testing.T) { - input := setupTestInput() - ctx := input.ctx - - // set coins initially - input.fck.setCollectedFees(ctx, twoCoins) - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(twoCoins)) - - // clear fees and see that pool is now empty - input.fck.ClearCollectedFees(ctx) - require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(emptyCoins)) -} diff --git a/x/auth/types/genesis.go b/x/auth/types/genesis.go index d72393804..3cf059fb5 100644 --- a/x/auth/types/genesis.go +++ b/x/auth/types/genesis.go @@ -2,27 +2,21 @@ package types import ( "fmt" - - sdk "github.com/cosmos/cosmos-sdk/types" ) // GenesisState - all auth state that must be provided at genesis type GenesisState struct { - CollectedFees sdk.Coins `json:"collected_fees"` - Params Params `json:"params"` + Params Params `json:"params"` } // NewGenesisState - Create a new genesis state -func NewGenesisState(collectedFees sdk.Coins, params Params) GenesisState { - return GenesisState{ - CollectedFees: collectedFees, - Params: params, - } +func NewGenesisState(params Params) GenesisState { + return GenesisState{params} } // DefaultGenesisState - Return a default genesis state func DefaultGenesisState() GenesisState { - return NewGenesisState(sdk.NewCoins(), DefaultParams()) + return NewGenesisState(DefaultParams()) } // ValidateGenesis performs basic validation of auth genesis data returning an diff --git a/x/auth/types/keys.go b/x/auth/types/keys.go index 30cf80490..a0bc7dd06 100644 --- a/x/auth/types/keys.go +++ b/x/auth/types/keys.go @@ -1,6 +1,8 @@ package types -import sdk "github.com/cosmos/cosmos-sdk/types" +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) const ( // module name @@ -9,8 +11,8 @@ const ( // StoreKey is string representation of the store key for auth StoreKey = "acc" - // FeeStoreKey is a string representation of the store key for fees - FeeStoreKey = "fee" + // FeeCollectorName the root string for the fee collector account address + FeeCollectorName = "FeeCollector" // QuerierRoute is the querier route for acc QuerierRoute = StoreKey diff --git a/x/auth/types/test_common.go b/x/auth/types/test_common.go index 14e5d8910..0ab71393a 100644 --- a/x/auth/types/test_common.go +++ b/x/auth/types/test_common.go @@ -2,49 +2,12 @@ package types import ( - abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/secp256k1" - dbm "github.com/tendermint/tendermint/libs/db" - "github.com/tendermint/tendermint/libs/log" - "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/store" sdk "github.com/cosmos/cosmos-sdk/types" ) -//DONTCOVER - -type testInput struct { - cdc *codec.Codec - ctx sdk.Context - fck FeeCollectionKeeper -} - -func setupTestInput() testInput { - db := dbm.NewMemDB() - - cdc := codec.New() - RegisterBaseAccount(cdc) - - authCapKey := sdk.NewKVStoreKey("authCapKey") - fckCapKey := sdk.NewKVStoreKey("fckCapKey") - keyParams := sdk.NewKVStoreKey("subspace") - tkeyParams := sdk.NewTransientStoreKey("transient_subspace") - - ms := store.NewCommitMultiStore(db) - ms.MountStoreWithDB(authCapKey, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(fckCapKey, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) - ms.LoadLatestVersion() - - fck := NewFeeCollectionKeeper(cdc, fckCapKey) - ctx := sdk.NewContext(ms, abci.Header{ChainID: "test-chain-id"}, false, log.NewNopLogger()) - - return testInput{cdc: cdc, ctx: ctx, fck: fck} -} - func NewTestMsg(addrs ...sdk.AccAddress) *sdk.TestMsg { return sdk.NewTestMsg(addrs...) } diff --git a/x/bank/app_test.go b/x/bank/app_test.go index 066d40641..e2eec1024 100644 --- a/x/bank/app_test.go +++ b/x/bank/app_test.go @@ -9,6 +9,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank/internal/keeper" "github.com/cosmos/cosmos-sdk/x/bank/internal/types" "github.com/cosmos/cosmos-sdk/x/mock" + supplytypes "github.com/cosmos/cosmos-sdk/x/supply/types" "github.com/stretchr/testify/require" @@ -92,6 +93,7 @@ var ( // initialize the mock application for this module func getMockApp(t *testing.T) *mock.App { mapp, err := getBenchmarkMockApp() + supplytypes.RegisterCodec(mapp.Cdc) require.NoError(t, err) return mapp } @@ -274,12 +276,14 @@ func TestMsgMultiSendMultipleInOut(t *testing.T) { func TestMsgMultiSendDependent(t *testing.T) { mapp := getMockApp(t) - acc1 := &auth.BaseAccount{ - Address: addr1, - Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)}, - } + acc1 := auth.NewBaseAccountWithAddress(addr1) + acc2 := auth.NewBaseAccountWithAddress(addr2) + err := acc1.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 42))) + require.NoError(t, err) + err = acc2.SetAccountNumber(1) + require.NoError(t, err) - mock.SetGenesis(mapp, []auth.Account{acc1}) + mock.SetGenesis(mapp, []auth.Account{&acc1, &acc2}) testCases := []appTestCase{ { diff --git a/x/bank/internal/keeper/keeper.go b/x/bank/internal/keeper/keeper.go index 5b29516d2..45946b605 100644 --- a/x/bank/internal/keeper/keeper.go +++ b/x/bank/internal/keeper/keeper.go @@ -24,8 +24,8 @@ type Keeper interface { AddCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Error) InputOutputCoins(ctx sdk.Context, inputs []types.Input, outputs []types.Output) sdk.Error - DelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error - UndelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error + DelegateCoins(ctx sdk.Context, delegatorAddr, moduleAccAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + UndelegateCoins(ctx sdk.Context, moduleAccAddr, delegatorAddr sdk.AccAddress, amt sdk.Coins) sdk.Error } // BaseKeeper manages transfers between accounts. It implements the Keeper interface. @@ -53,10 +53,6 @@ func NewBaseKeeper(ak types.AccountKeeper, func (keeper BaseKeeper) SetCoins( ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins, ) sdk.Error { - - if !amt.IsValid() { - return sdk.ErrInvalidCoins(amt.String()) - } return setCoins(ctx, keeper.ak, addr, amt) } @@ -64,10 +60,6 @@ func (keeper BaseKeeper) SetCoins( func (keeper BaseKeeper) SubtractCoins( ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins, ) (sdk.Coins, sdk.Error) { - - if !amt.IsValid() { - return nil, sdk.ErrInvalidCoins(amt.String()) - } return subtractCoins(ctx, keeper.ak, addr, amt) } @@ -75,10 +67,6 @@ func (keeper BaseKeeper) SubtractCoins( func (keeper BaseKeeper) AddCoins( ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins, ) (sdk.Coins, sdk.Error) { - - if !amt.IsValid() { - return nil, sdk.ErrInvalidCoins(amt.String()) - } return addCoins(ctx, keeper.ak, addr, amt) } @@ -90,22 +78,95 @@ func (keeper BaseKeeper) InputOutputCoins(ctx sdk.Context, inputs []types.Input, // DelegateCoins performs delegation by deducting amt coins from an account with // address addr. For vesting accounts, delegations amounts are tracked for both // vesting and vested coins. -func (keeper BaseKeeper) DelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error { +// The coins are then transferred from the delegator address to a ModuleAccount address. +// If any of the delegation amounts are negative, an error is returned. +func (keeper BaseKeeper) DelegateCoins( + ctx sdk.Context, delegatorAddr, moduleAccAddr sdk.AccAddress, amt sdk.Coins, +) sdk.Error { + + delegatorAcc := getAccount(ctx, keeper.ak, delegatorAddr) + if delegatorAcc == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("account %s does not exist", delegatorAddr)) + } + + moduleAcc := getAccount(ctx, keeper.ak, moduleAccAddr) + if moduleAcc == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", moduleAccAddr)) + } + if !amt.IsValid() { return sdk.ErrInvalidCoins(amt.String()) } - return delegateCoins(ctx, keeper.ak, addr, amt) + + oldCoins := delegatorAcc.GetCoins() + + _, hasNeg := oldCoins.SafeSub(amt) + if hasNeg { + return sdk.ErrInsufficientCoins( + fmt.Sprintf("insufficient account funds; %s < %s", oldCoins, amt), + ) + } + + // TODO: return error on account.TrackDelegation + if err := trackDelegation(delegatorAcc, ctx.BlockHeader().Time, amt); err != nil { + return sdk.ErrInternal(fmt.Sprintf("failed to track delegation: %v", err)) + } + + setAccount(ctx, keeper.ak, delegatorAcc) + + _, err := addCoins(ctx, keeper.ak, moduleAccAddr, amt) + if err != nil { + return err + } + + return nil } // UndelegateCoins performs undelegation by crediting amt coins to an account with // address addr. For vesting accounts, undelegation amounts are tracked for both // vesting and vested coins. +// The coins are then transferred from a ModuleAccount address to the delegator address. // If any of the undelegation amounts are negative, an error is returned. -func (keeper BaseKeeper) UndelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error { +func (keeper BaseKeeper) UndelegateCoins( + ctx sdk.Context, moduleAccAddr, delegatorAddr sdk.AccAddress, amt sdk.Coins, +) sdk.Error { + + delegatorAcc := getAccount(ctx, keeper.ak, delegatorAddr) + if delegatorAcc == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("account %s does not exist", delegatorAddr)) + } + + moduleAcc := getAccount(ctx, keeper.ak, moduleAccAddr) + if moduleAcc == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", moduleAccAddr)) + } + if !amt.IsValid() { return sdk.ErrInvalidCoins(amt.String()) } - return undelegateCoins(ctx, keeper.ak, addr, amt) + + oldCoins := moduleAcc.GetCoins() + + newCoins, hasNeg := oldCoins.SafeSub(amt) + if hasNeg { + return sdk.ErrInsufficientCoins( + fmt.Sprintf("insufficient account funds; %s < %s", oldCoins, amt), + ) + } + + err := setCoins(ctx, keeper.ak, moduleAccAddr, newCoins) + if err != nil { + return err + } + + // TODO: return error on account.TrackUndelegation + if err := trackUndelegation(delegatorAcc, amt); err != nil { + return sdk.ErrInternal(fmt.Sprintf("failed to track undelegation: %v", err)) + } + + setAccount(ctx, keeper.ak, delegatorAcc) + + return nil } // SendKeeper defines a module interface that facilitates the transfer of coins @@ -141,6 +202,7 @@ func NewBaseSendKeeper(ak types.AccountKeeper, } } +// TODO combine with sendCoins // SendCoins moves coins from one account to another func (keeper BaseSendKeeper) SendCoins( ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins, @@ -199,6 +261,11 @@ func NewBaseViewKeeper(ak types.AccountKeeper, codespace sdk.CodespaceType) Base return BaseViewKeeper{ak: ak, codespace: codespace} } +// Logger returns a module-specific logger. +func (keeper BaseViewKeeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName)) +} + // GetCoins returns the coins at the addr. func (keeper BaseViewKeeper) GetCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins { return getCoins(ctx, keeper.ak, addr) @@ -214,13 +281,9 @@ func (keeper BaseViewKeeper) Codespace() sdk.CodespaceType { return keeper.codespace } -// Logger returns a module-specific logger. -func (keeper BaseViewKeeper) Logger(ctx sdk.Context) log.Logger { - return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName)) -} - -func getCoins(ctx sdk.Context, ak types.AccountKeeper, addr sdk.AccAddress) sdk.Coins { - acc := ak.GetAccount(ctx, addr) +// getCoins returns the account coins +func getCoins(ctx sdk.Context, am types.AccountKeeper, addr sdk.AccAddress) sdk.Coins { + acc := am.GetAccount(ctx, addr) if acc == nil { return sdk.NewCoins() } @@ -252,10 +315,12 @@ func hasCoins(ctx sdk.Context, ak types.AccountKeeper, addr sdk.AccAddress, amt return getCoins(ctx, ak, addr).IsAllGTE(amt) } +// getAccount implements AccountKeeper func getAccount(ctx sdk.Context, ak types.AccountKeeper, addr sdk.AccAddress) exported.Account { return ak.GetAccount(ctx, addr) } +// setAccount implements AccountKeeper func setAccount(ctx sdk.Context, ak types.AccountKeeper, acc exported.Account) { ak.SetAccount(ctx, acc) } @@ -313,11 +378,7 @@ func addCoins(ctx sdk.Context, ak types.AccountKeeper, addr sdk.AccAddress, amt // SendCoins moves coins from one account to another // Returns ErrInvalidCoins if amt is invalid. -func sendCoins(ctx sdk.Context, ak types.AccountKeeper, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) sdk.Error { - // Safety check ensuring that when sending coins the keeper must maintain the - if !amt.IsValid() { - return sdk.ErrInvalidCoins(amt.String()) - } +func sendCoins(ctx sdk.Context, ak types.AccountKeeper, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) sdk.Error { _, err := subtractCoins(ctx, ak, fromAddr, amt) if err != nil { @@ -372,51 +433,6 @@ func inputOutputCoins(ctx sdk.Context, ak types.AccountKeeper, inputs []types.In return nil } -func delegateCoins(ctx sdk.Context, ak types.AccountKeeper, addr sdk.AccAddress, amt sdk.Coins) sdk.Error { - if !amt.IsValid() { - return sdk.ErrInvalidCoins(amt.String()) - } - - acc := getAccount(ctx, ak, addr) - if acc == nil { - return sdk.ErrUnknownAddress(fmt.Sprintf("account %s does not exist", addr)) - } - - oldCoins := acc.GetCoins() - - _, hasNeg := oldCoins.SafeSub(amt) - if hasNeg { - return sdk.ErrInsufficientCoins( - fmt.Sprintf("insufficient account funds; %s < %s", oldCoins, amt), - ) - } - - if err := trackDelegation(acc, ctx.BlockHeader().Time, amt); err != nil { - return sdk.ErrInternal(fmt.Sprintf("failed to track delegation: %v", err)) - } - - setAccount(ctx, ak, acc) - return nil -} - -func undelegateCoins(ctx sdk.Context, ak types.AccountKeeper, addr sdk.AccAddress, amt sdk.Coins) sdk.Error { - if !amt.IsValid() { - return sdk.ErrInvalidCoins(amt.String()) - } - - acc := getAccount(ctx, ak, addr) - if acc == nil { - return sdk.ErrUnknownAddress(fmt.Sprintf("account %s does not exist", addr)) - } - - if err := trackUndelegation(acc, amt); err != nil { - return sdk.ErrInternal(fmt.Sprintf("failed to track undelegation: %v", err)) - } - - setAccount(ctx, ak, acc) - return nil -} - // CONTRACT: assumes that amt is valid. func trackDelegation(acc exported.Account, blockTime time.Time, amt sdk.Coins) error { vacc, ok := acc.(exported.VestingAccount) diff --git a/x/bank/internal/keeper/keeper_test.go b/x/bank/internal/keeper/keeper_test.go index cd46b22ef..fa0d9ee5b 100644 --- a/x/bank/internal/keeper/keeper_test.go +++ b/x/bank/internal/keeper/keeper_test.go @@ -5,6 +5,7 @@ import ( "time" "github.com/stretchr/testify/require" + abci "github.com/tendermint/tendermint/abci/types" dbm "github.com/tendermint/tendermint/libs/db" "github.com/tendermint/tendermint/libs/log" @@ -30,16 +31,15 @@ func setupTestInput() testInput { db := dbm.NewMemDB() cdc := codec.New() - auth.RegisterBaseAccount(cdc) + auth.RegisterCodec(cdc) + codec.RegisterCrypto(cdc) authCapKey := sdk.NewKVStoreKey("authCapKey") - fckCapKey := sdk.NewKVStoreKey("fckCapKey") keyParams := sdk.NewKVStoreKey("params") tkeyParams := sdk.NewTransientStoreKey("transient_params") ms := store.NewCommitMultiStore(db) ms.MountStoreWithDB(authCapKey, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(fckCapKey, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) ms.LoadLatestVersion() @@ -283,25 +283,30 @@ func TestDelegateCoins(t *testing.T) { addr1 := sdk.AccAddress([]byte("addr1")) addr2 := sdk.AccAddress([]byte("addr2")) + addrModule := sdk.AccAddress([]byte("moduleAcc")) bacc := auth.NewBaseAccountWithAddress(addr1) bacc.SetCoins(origCoins) + macc := input.ak.NewAccountWithAddress(ctx, addrModule) // we don't need to define an actual module account bc we just need the address for testing vacc := auth.NewContinuousVestingAccount(&bacc, ctx.BlockHeader().Time.Unix(), endTime.Unix()) acc := input.ak.NewAccountWithAddress(ctx, addr2) input.ak.SetAccount(ctx, vacc) input.ak.SetAccount(ctx, acc) + input.ak.SetAccount(ctx, macc) input.k.SetCoins(ctx, addr2, origCoins) ctx = ctx.WithBlockTime(now.Add(12 * time.Hour)) // require the ability for a non-vesting account to delegate - err := input.k.DelegateCoins(ctx, addr2, delCoins) + err := input.k.DelegateCoins(ctx, addr2, addrModule, delCoins) acc = input.ak.GetAccount(ctx, addr2) + macc = input.ak.GetAccount(ctx, addrModule) require.NoError(t, err) - require.Equal(t, delCoins, acc.GetCoins()) + require.Equal(t, origCoins.Sub(delCoins), acc.GetCoins()) + require.Equal(t, delCoins, macc.GetCoins()) // require the ability for a vesting account to delegate - err = input.k.DelegateCoins(ctx, addr1, delCoins) + err = input.k.DelegateCoins(ctx, addr1, addrModule, delCoins) vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount) require.NoError(t, err) require.Equal(t, delCoins, vacc.GetCoins()) @@ -318,36 +323,53 @@ func TestUndelegateCoins(t *testing.T) { addr1 := sdk.AccAddress([]byte("addr1")) addr2 := sdk.AccAddress([]byte("addr2")) + addrModule := sdk.AccAddress([]byte("moduleAcc")) bacc := auth.NewBaseAccountWithAddress(addr1) bacc.SetCoins(origCoins) + macc := input.ak.NewAccountWithAddress(ctx, addrModule) // we don't need to define an actual module account bc we just need the address for testing vacc := auth.NewContinuousVestingAccount(&bacc, ctx.BlockHeader().Time.Unix(), endTime.Unix()) acc := input.ak.NewAccountWithAddress(ctx, addr2) input.ak.SetAccount(ctx, vacc) input.ak.SetAccount(ctx, acc) + input.ak.SetAccount(ctx, macc) input.k.SetCoins(ctx, addr2, origCoins) ctx = ctx.WithBlockTime(now.Add(12 * time.Hour)) // require the ability for a non-vesting account to delegate - err := input.k.DelegateCoins(ctx, addr2, delCoins) - require.NoError(t, err) - - // require the ability for a non-vesting account to undelegate - err = input.k.UndelegateCoins(ctx, addr2, delCoins) + err := input.k.DelegateCoins(ctx, addr2, addrModule, delCoins) require.NoError(t, err) acc = input.ak.GetAccount(ctx, addr2) - require.Equal(t, origCoins, acc.GetCoins()) + macc = input.ak.GetAccount(ctx, addrModule) + require.Equal(t, origCoins.Sub(delCoins), acc.GetCoins()) + require.Equal(t, delCoins, macc.GetCoins()) - // require the ability for a vesting account to delegate - err = input.k.DelegateCoins(ctx, addr1, delCoins) + // require the ability for a non-vesting account to undelegate + err = input.k.UndelegateCoins(ctx, addrModule, addr2, delCoins) require.NoError(t, err) - // require the ability for a vesting account to undelegate - err = input.k.UndelegateCoins(ctx, addr1, delCoins) + acc = input.ak.GetAccount(ctx, addr2) + macc = input.ak.GetAccount(ctx, addrModule) + require.Equal(t, origCoins, acc.GetCoins()) + require.True(t, macc.GetCoins().Empty()) + + // require the ability for a vesting account to delegate + err = input.k.DelegateCoins(ctx, addr1, addrModule, delCoins) require.NoError(t, err) vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount) + macc = input.ak.GetAccount(ctx, addrModule) + require.Equal(t, origCoins.Sub(delCoins), vacc.GetCoins()) + require.Equal(t, delCoins, macc.GetCoins()) + + // require the ability for a vesting account to undelegate + err = input.k.UndelegateCoins(ctx, addrModule, addr1, delCoins) + require.NoError(t, err) + + vacc = input.ak.GetAccount(ctx, addr1).(*auth.ContinuousVestingAccount) + macc = input.ak.GetAccount(ctx, addrModule) require.Equal(t, origCoins, vacc.GetCoins()) + require.True(t, macc.GetCoins().Empty()) } diff --git a/x/bank/internal/keeper/querier.go b/x/bank/internal/keeper/querier.go index b02d7dee2..5a0fd3910 100644 --- a/x/bank/internal/keeper/querier.go +++ b/x/bank/internal/keeper/querier.go @@ -11,6 +11,7 @@ import ( ) const ( + // query balance path QueryBalance = "balances" ) diff --git a/x/crisis/expected_keepers.go b/x/crisis/expected_keepers.go deleted file mode 100644 index 9e505ca4c..000000000 --- a/x/crisis/expected_keepers.go +++ /dev/null @@ -1,20 +0,0 @@ -package crisis - -import ( - sdk "github.com/cosmos/cosmos-sdk/types" -) - -// expected bank keeper -type DistrKeeper interface { - DistributeFeePool(ctx sdk.Context, amount sdk.Coins, receiveAddr sdk.AccAddress) sdk.Error -} - -// expected fee collection keeper -type FeeCollectionKeeper interface { - AddCollectedFees(ctx sdk.Context, coins sdk.Coins) sdk.Coins -} - -// expected bank keeper -type BankKeeper interface { - SubtractCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Error) -} diff --git a/x/crisis/handler.go b/x/crisis/handler.go index 867d3203a..fa627a7cc 100644 --- a/x/crisis/handler.go +++ b/x/crisis/handler.go @@ -29,13 +29,11 @@ func handleMsgVerifyInvariant(ctx sdk.Context, msg types.MsgVerifyInvariant, k K // remove the constant fee constantFee := sdk.NewCoins(k.GetConstantFee(ctx)) - _, err := k.bankKeeper.SubtractCoins(ctx, msg.Sender, constantFee) + err := k.supplyKeeper.SendCoinsFromAccountToModule(ctx, msg.Sender, k.feeCollectorName, constantFee) if err != nil { return err.Result() } - _ = k.feeCollectionKeeper.AddCollectedFees(ctx, constantFee) - // use a cached context to avoid gas costs during invariants cacheCtx, _ := ctx.CacheContext() @@ -62,7 +60,7 @@ func handleMsgVerifyInvariant(ctx sdk.Context, msg types.MsgVerifyInvariant, k K // TODO uncomment the following code block with implementation of the circuit breaker //// refund constant fee - //err := k.distrKeeper.DistributeFeePool(ctx, constantFee, msg.Sender) + //err := k.distrKeeper.DistributeFromFeePool(ctx, constantFee, msg.Sender) //if err != nil { //// if there are insufficient coins to refund, log the error, //// but still halt the chain. diff --git a/x/crisis/handler_test.go b/x/crisis/handler_test.go index 6e8a0941a..392903b71 100644 --- a/x/crisis/handler_test.go +++ b/x/crisis/handler_test.go @@ -24,11 +24,11 @@ var ( func CreateTestInput(t *testing.T) (sdk.Context, Keeper, auth.AccountKeeper, distr.Keeper) { communityTax := sdk.NewDecWithPrec(2, 2) - ctx, accKeeper, bankKeeper, distrKeeper, _, feeCollectionKeeper, paramsKeeper := + ctx, accKeeper, _, distrKeeper, _, paramsKeeper, supplyKeeper := distr.CreateTestInputAdvanced(t, false, 10, communityTax) paramSpace := paramsKeeper.Subspace(DefaultParamspace) - crisisKeeper := NewKeeper(paramSpace, 1, distrKeeper, bankKeeper, feeCollectionKeeper) + crisisKeeper := NewKeeper(paramSpace, 1, supplyKeeper, auth.FeeCollectorName) constantFee := sdk.NewInt64Coin("stake", 10000000) crisisKeeper.SetConstantFee(ctx, constantFee) diff --git a/x/crisis/keeper.go b/x/crisis/keeper.go index 1468dcc2f..a6f331d31 100644 --- a/x/crisis/keeper.go +++ b/x/crisis/keeper.go @@ -17,23 +17,21 @@ type Keeper struct { paramSpace params.Subspace invCheckPeriod uint - distrKeeper DistrKeeper - bankKeeper BankKeeper - feeCollectionKeeper FeeCollectionKeeper + supplyKeeper types.SupplyKeeper + + feeCollectorName string // name of the FeeCollector ModuleAccount } // NewKeeper creates a new Keeper object func NewKeeper(paramSpace params.Subspace, invCheckPeriod uint, - distrKeeper DistrKeeper, bankKeeper BankKeeper, - feeCollectionKeeper FeeCollectionKeeper) Keeper { + supplyKeeper types.SupplyKeeper, feeCollectorName string) Keeper { return Keeper{ - routes: []types.InvarRoute{}, - paramSpace: paramSpace.WithKeyTable(types.ParamKeyTable()), - invCheckPeriod: invCheckPeriod, - distrKeeper: distrKeeper, - bankKeeper: bankKeeper, - feeCollectionKeeper: feeCollectionKeeper, + routes: []types.InvarRoute{}, + paramSpace: paramSpace.WithKeyTable(types.ParamKeyTable()), + invCheckPeriod: invCheckPeriod, + supplyKeeper: supplyKeeper, + feeCollectorName: feeCollectorName, } } @@ -42,7 +40,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger { return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName)) } -// register routes for the +// RegisterRoute register the routes for each of the invariants func (k *Keeper) RegisterRoute(moduleName, route string, invar sdk.Invariant) { invarRoute := types.NewInvarRoute(moduleName, route, invar) k.routes = append(k.routes, invarRoute) diff --git a/x/crisis/module.go b/x/crisis/module.go index d544b8072..c36f8a72e 100644 --- a/x/crisis/module.go +++ b/x/crisis/module.go @@ -13,6 +13,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/x/crisis/client/cli" + "github.com/cosmos/cosmos-sdk/x/crisis/types" ) var ( @@ -37,13 +38,16 @@ func (AppModuleBasic) RegisterCodec(cdc *codec.Codec) { // default genesis state func (AppModuleBasic) DefaultGenesis() json.RawMessage { - return ModuleCdc.MustMarshalJSON(DefaultGenesisState()) + return types.ModuleCdc.MustMarshalJSON(DefaultGenesisState()) } // module validate genesis func (AppModuleBasic) ValidateGenesis(bz json.RawMessage) error { - // TODO - return nil + var data types.GenesisState + if err := types.ModuleCdc.UnmarshalJSON(bz, &data); err != nil { + return err + } + return types.ValidateGenesis(data) } // register rest routes @@ -99,7 +103,7 @@ func (AppModule) NewQuerierHandler() sdk.Querier { return nil } // module init-genesis func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.ValidatorUpdate { var genesisState GenesisState - ModuleCdc.MustUnmarshalJSON(data, &genesisState) + types.ModuleCdc.MustUnmarshalJSON(data, &genesisState) InitGenesis(ctx, am.keeper, genesisState) am.keeper.AssertInvariants(ctx) @@ -109,7 +113,7 @@ func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.Va // module export genesis func (am AppModule) ExportGenesis(ctx sdk.Context) json.RawMessage { gs := ExportGenesis(ctx, am.keeper) - return ModuleCdc.MustMarshalJSON(gs) + return types.ModuleCdc.MustMarshalJSON(gs) } // module begin-block diff --git a/x/crisis/types/expected_keepers.go b/x/crisis/types/expected_keepers.go new file mode 100644 index 000000000..5690c0c38 --- /dev/null +++ b/x/crisis/types/expected_keepers.go @@ -0,0 +1,10 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// SupplyKeeper defines the expected supply keeper (noalias) +type SupplyKeeper interface { + SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) sdk.Error +} diff --git a/x/crisis/types/genesis.go b/x/crisis/types/genesis.go index 1a7e0f9ae..921f4cdf0 100644 --- a/x/crisis/types/genesis.go +++ b/x/crisis/types/genesis.go @@ -1,6 +1,8 @@ package types import ( + "fmt" + sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -22,3 +24,11 @@ func DefaultGenesisState() GenesisState { ConstantFee: sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000)), } } + +// ValidateGenesis - validate crisis genesis data +func ValidateGenesis(data GenesisState) error { + if !data.ConstantFee.IsPositive() { + return fmt.Errorf("constant fee must be positive: %s", data.ConstantFee) + } + return nil +} diff --git a/x/distribution/alias.go b/x/distribution/alias.go index 7cb5afe96..4c898251f 100644 --- a/x/distribution/alias.go +++ b/x/distribution/alias.go @@ -46,6 +46,7 @@ var ( NonNegativeOutstandingInvariant = keeper.NonNegativeOutstandingInvariant CanWithdrawInvariant = keeper.CanWithdrawInvariant ReferenceCountInvariant = keeper.ReferenceCountInvariant + ModuleAccountInvariant = keeper.ModuleAccountInvariant NewKeeper = keeper.NewKeeper GetValidatorOutstandingRewardsAddress = keeper.GetValidatorOutstandingRewardsAddress GetDelegatorWithdrawInfoAddress = keeper.GetDelegatorWithdrawInfoAddress @@ -127,13 +128,8 @@ var ( type ( Hooks = keeper.Hooks Keeper = keeper.Keeper - DummyFeeCollectionKeeper = keeper.DummyFeeCollectionKeeper DelegatorStartingInfo = types.DelegatorStartingInfo CodeType = types.CodeType - StakingKeeper = types.StakingKeeper - StakingHooks = types.StakingHooks - BankKeeper = types.BankKeeper - FeeCollectionKeeper = types.FeeCollectionKeeper FeePool = types.FeePool DelegatorWithdrawInfo = types.DelegatorWithdrawInfo ValidatorOutstandingRewardsRecord = types.ValidatorOutstandingRewardsRecord diff --git a/x/distribution/genesis.go b/x/distribution/genesis.go index 524e2237c..77a603baa 100644 --- a/x/distribution/genesis.go +++ b/x/distribution/genesis.go @@ -1,23 +1,29 @@ package distribution import ( + "fmt" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution/types" ) // InitGenesis sets distribution information for genesis -func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) { +func InitGenesis(ctx sdk.Context, keeper Keeper, supplyKeeper types.SupplyKeeper, data types.GenesisState) { + var moduleHoldings sdk.DecCoins + keeper.SetFeePool(ctx, data.FeePool) keeper.SetCommunityTax(ctx, data.CommunityTax) keeper.SetBaseProposerReward(ctx, data.BaseProposerReward) keeper.SetBonusProposerReward(ctx, data.BonusProposerReward) keeper.SetWithdrawAddrEnabled(ctx, data.WithdrawAddrEnabled) + for _, dwi := range data.DelegatorWithdrawInfos { keeper.SetDelegatorWithdrawAddr(ctx, dwi.DelegatorAddress, dwi.WithdrawAddress) } keeper.SetPreviousProposerConsAddr(ctx, data.PreviousProposer) for _, rew := range data.OutstandingRewards { keeper.SetValidatorOutstandingRewards(ctx, rew.ValidatorAddress, rew.OutstandingRewards) + moduleHoldings = moduleHoldings.Add(rew.OutstandingRewards) } for _, acc := range data.ValidatorAccumulatedCommissions { keeper.SetValidatorAccumulatedCommission(ctx, acc.ValidatorAddress, acc.Accumulated) @@ -34,6 +40,22 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) { for _, evt := range data.ValidatorSlashEvents { keeper.SetValidatorSlashEvent(ctx, evt.ValidatorAddress, evt.Height, evt.Event) } + + moduleHoldings = moduleHoldings.Add(data.FeePool.CommunityPool) + moduleHoldingsInt, _ := moduleHoldings.TruncateDecimal() + + // check if the module account exists + moduleAcc := keeper.GetDistributionAccount(ctx) + if moduleAcc == nil { + panic(fmt.Sprintf("%s module account has not been set", types.ModuleName)) + } + + if moduleAcc.GetCoins().IsZero() { + if err := moduleAcc.SetCoins(moduleHoldingsInt); err != nil { + panic(err) + } + supplyKeeper.SetModuleAccount(ctx, moduleAcc) + } } // ExportGenesis returns a GenesisState for a given context and keeper. diff --git a/x/distribution/keeper/alias_functions.go b/x/distribution/keeper/alias_functions.go index 6081cf348..a02d2f2a0 100644 --- a/x/distribution/keeper/alias_functions.go +++ b/x/distribution/keeper/alias_functions.go @@ -2,6 +2,8 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution/types" + "github.com/cosmos/cosmos-sdk/x/supply/exported" ) // get outstanding rewards @@ -13,3 +15,8 @@ func (k Keeper) GetValidatorOutstandingRewardsCoins(ctx sdk.Context, val sdk.Val func (k Keeper) GetFeePoolCommunityCoins(ctx sdk.Context) sdk.DecCoins { return k.GetFeePool(ctx).CommunityPool } + +// GetDistributionAccount returns the distribution ModuleAccount +func (k Keeper) GetDistributionAccount(ctx sdk.Context) exported.ModuleAccountI { + return k.supplyKeeper.GetModuleAccount(ctx, types.ModuleName) +} diff --git a/x/distribution/keeper/allocation.go b/x/distribution/keeper/allocation.go index 6da5d6d80..f902e79d7 100644 --- a/x/distribution/keeper/allocation.go +++ b/x/distribution/keeper/allocation.go @@ -10,7 +10,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/staking/exported" ) -// allocate fees handles distribution of the collected fees +// AllocateTokens handles distribution of the collected fees func (k Keeper) AllocateTokens( ctx sdk.Context, sumPreviousPrecommitPower, totalPreviousPower int64, previousProposer sdk.ConsAddress, previousVotes []abci.VoteInfo, @@ -21,9 +21,15 @@ func (k Keeper) AllocateTokens( // fetch and clear the collected fees for distribution, since this is // called in BeginBlock, collected fees will be from the previous block // (and distributed to the previous proposer) - feesCollectedInt := k.feeCollectionKeeper.GetCollectedFees(ctx) + feeCollector := k.supplyKeeper.GetModuleAccount(ctx, k.feeCollectorName) + feesCollectedInt := feeCollector.GetCoins() feesCollected := sdk.NewDecCoins(feesCollectedInt) - k.feeCollectionKeeper.ClearCollectedFees(ctx) + + // transfer collected fees to the distribution module account + err := k.supplyKeeper.SendCoinsFromModuleToModule(ctx, k.feeCollectorName, types.ModuleName, feesCollectedInt) + if err != nil { + panic(err) + } // temporary workaround to keep CanWithdrawInvariant happy // general discussions here: https://github.com/cosmos/cosmos-sdk/issues/2906#issuecomment-441867634 diff --git a/x/distribution/keeper/allocation_test.go b/x/distribution/keeper/allocation_test.go index 161a91198..4d2d33dc9 100644 --- a/x/distribution/keeper/allocation_test.go +++ b/x/distribution/keeper/allocation_test.go @@ -38,7 +38,7 @@ func TestAllocateTokensToValidatorWithCommission(t *testing.T) { } func TestAllocateTokensToManyValidators(t *testing.T) { - ctx, _, k, sk, fck := CreateTestInputDefault(t, false, 1000) + ctx, ak, k, sk, supplyKeeper := CreateTestInputDefault(t, false, 1000) sh := staking.NewHandler(sk) // create validator with 50% commission @@ -72,10 +72,14 @@ func TestAllocateTokensToManyValidators(t *testing.T) { require.True(t, k.GetValidatorCurrentRewards(ctx, valOpAddr2).Rewards.IsZero()) // allocate tokens as if both had voted and second was proposer - fees := sdk.Coins{ - {sdk.DefaultBondDenom, sdk.NewInt(100)}, - } - fck.SetCollectedFees(fees) + fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100))) + feeCollector := supplyKeeper.GetModuleAccount(ctx, k.feeCollectorName) + require.NotNil(t, feeCollector) + + err := feeCollector.SetCoins(fees) + require.NoError(t, err) + ak.SetAccount(ctx, feeCollector) + votes := []abci.VoteInfo{ { Validator: abciValA, @@ -105,7 +109,7 @@ func TestAllocateTokensToManyValidators(t *testing.T) { func TestAllocateTokensTruncation(t *testing.T) { communityTax := sdk.NewDec(0) - ctx, _, _, k, sk, fck, _ := CreateTestInputAdvanced(t, false, 1000000, communityTax) + ctx, ak, _, k, sk, _, supplyKeeper := CreateTestInputAdvanced(t, false, 1000000, communityTax) sh := staking.NewHandler(sk) // create validator with 10% commission @@ -150,10 +154,16 @@ func TestAllocateTokensTruncation(t *testing.T) { require.True(t, k.GetValidatorCurrentRewards(ctx, valOpAddr2).Rewards.IsZero()) // allocate tokens as if both had voted and second was proposer - fees := sdk.Coins{ - sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(634195840)), - } - fck.SetCollectedFees(fees) + fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(634195840))) + + feeCollector := supplyKeeper.GetModuleAccount(ctx, k.feeCollectorName) + require.NotNil(t, feeCollector) + + err := feeCollector.SetCoins(fees) + require.NoError(t, err) + + ak.SetAccount(ctx, feeCollector) + votes := []abci.VoteInfo{ { Validator: abciValA, diff --git a/x/distribution/keeper/delegation.go b/x/distribution/keeper/delegation.go index 9755bc571..00f6e2b2b 100644 --- a/x/distribution/keeper/delegation.go +++ b/x/distribution/keeper/delegation.go @@ -173,7 +173,8 @@ func (k Keeper) withdrawDelegationRewards(ctx sdk.Context, val exported.Validato // add coins to user account if !coins.IsZero() { withdrawAddr := k.GetDelegatorWithdrawAddr(ctx, del.GetDelegatorAddr()) - if _, err := k.bankKeeper.AddCoins(ctx, withdrawAddr, coins); err != nil { + err := k.supplyKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, withdrawAddr, coins) + if err != nil { return nil, err } } diff --git a/x/distribution/keeper/delegation_test.go b/x/distribution/keeper/delegation_test.go index a0ace76bc..b0e47f533 100644 --- a/x/distribution/keeper/delegation_test.go +++ b/x/distribution/keeper/delegation_test.go @@ -266,6 +266,11 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) { ctx, ak, k, sk, _ := CreateTestInputDefault(t, false, balancePower) sh := staking.NewHandler(sk) + // set module account coins + distrAcc := k.GetDistributionAccount(ctx) + distrAcc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, balanceTokens))) + k.supplyKeeper.SetModuleAccount(ctx, distrAcc) + // create validator with 50% commission power := int64(100) valTokens := sdk.TokensFromConsensusPower(power) @@ -473,8 +478,13 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) { func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) { ctx, _, k, sk, _ := CreateTestInputDefault(t, false, 1000) sh := staking.NewHandler(sk) - initial := int64(20) + + // set module account coins + distrAcc := k.GetDistributionAccount(ctx) + distrAcc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000)))) + k.supplyKeeper.SetModuleAccount(ctx, distrAcc) + totalRewards := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, sdk.NewDec(initial*2))} tokens := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, sdk.NewDec(initial))} diff --git a/x/distribution/keeper/fee_pool.go b/x/distribution/keeper/fee_pool.go index 779a58d13..a16e8258c 100644 --- a/x/distribution/keeper/fee_pool.go +++ b/x/distribution/keeper/fee_pool.go @@ -5,17 +5,21 @@ import ( "github.com/cosmos/cosmos-sdk/x/distribution/types" ) -// DistributeFeePool distributes funds from the the community pool to a receiver address -func (k Keeper) DistributeFeePool(ctx sdk.Context, amount sdk.Coins, receiveAddr sdk.AccAddress) sdk.Error { +// DistributeFromFeePool distributes funds from the distribution module account to +// a receiver address while updating the community pool +func (k Keeper) DistributeFromFeePool(ctx sdk.Context, amount sdk.Coins, receiveAddr sdk.AccAddress) sdk.Error { feePool := k.GetFeePool(ctx) - poolTruncated, _ := feePool.CommunityPool.TruncateDecimal() - if !poolTruncated.IsAllGTE(amount) { + // NOTE the community pool isn't a module account, however its coins + // are held in the distribution module account. Thus the community pool + // must be reduced separately from the SendCoinsFromModuleToAccount call + newPool, negative := feePool.CommunityPool.SafeSub(sdk.NewDecCoins(amount)) + if negative { return types.ErrBadDistribution(k.codespace) } + feePool.CommunityPool = newPool - feePool.CommunityPool.Sub(sdk.NewDecCoins(amount)) - _, err := k.bankKeeper.AddCoins(ctx, receiveAddr, amount) + err := k.supplyKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, receiveAddr, amount) if err != nil { return err } diff --git a/x/distribution/keeper/hooks.go b/x/distribution/keeper/hooks.go index e75a445d0..598809b30 100644 --- a/x/distribution/keeper/hooks.go +++ b/x/distribution/keeper/hooks.go @@ -2,7 +2,8 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/cosmos/cosmos-sdk/x/distribution/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // Wrapper struct @@ -10,7 +11,7 @@ type Hooks struct { k Keeper } -var _ types.StakingHooks = Hooks{} +var _ stakingtypes.StakingHooks = Hooks{} // Create new distribution hooks func (k Keeper) Hooks() Hooks { return Hooks{k} } @@ -46,8 +47,8 @@ func (h Hooks) AfterValidatorRemoved(ctx sdk.Context, _ sdk.ConsAddress, valAddr accAddr := sdk.AccAddress(valAddr) withdrawAddr := h.k.GetDelegatorWithdrawAddr(ctx, accAddr) - - if _, err := h.k.bankKeeper.AddCoins(ctx, withdrawAddr, coins); err != nil { + err := h.k.supplyKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, withdrawAddr, coins) + if err != nil { panic(err) } } diff --git a/x/distribution/keeper/invariants.go b/x/distribution/keeper/invariants.go index 568db2848..013a25535 100644 --- a/x/distribution/keeper/invariants.go +++ b/x/distribution/keeper/invariants.go @@ -16,6 +16,8 @@ func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper) { CanWithdrawInvariant(k)) ir.RegisterRoute(types.ModuleName, "reference-count", ReferenceCountInvariant(k)) + ir.RegisterRoute(types.ModuleName, "module-account", + ModuleAccountInvariant(k)) } // AllInvariants runs all invariants of the distribution module @@ -33,7 +35,7 @@ func AllInvariants(k Keeper) sdk.Invariant { if err != nil { return err } - return nil + return ModuleAccountInvariant(k)(ctx) } } @@ -135,3 +137,29 @@ func ReferenceCountInvariant(k Keeper) sdk.Invariant { return nil } } + +// ModuleAccountInvariant checks that the coins held by the distr ModuleAccount +// is consistent with the sum of validator outstanding rewards +func ModuleAccountInvariant(k Keeper) sdk.Invariant { + return func(ctx sdk.Context) error { + + var expectedCoins sdk.DecCoins + k.IterateValidatorOutstandingRewards(ctx, func(_ sdk.ValAddress, rewards types.ValidatorOutstandingRewards) (stop bool) { + expectedCoins = expectedCoins.Add(rewards) + return false + }) + + communityPool := k.GetFeePoolCommunityCoins(ctx) + expectedInt, _ := expectedCoins.Add(communityPool).TruncateDecimal() + + macc := k.GetDistributionAccount(ctx) + + if !macc.GetCoins().IsEqual(expectedInt) { + return fmt.Errorf("distribution ModuleAccount coins invariance:\n"+ + "\texpected ModuleAccount coins: %s\n"+ + "\tdistribution ModuleAccount coins : %s", expectedInt, macc.GetCoins()) + } + + return nil + } +} diff --git a/x/distribution/keeper/keeper.go b/x/distribution/keeper/keeper.go index 68c234dab..db8d9a17b 100644 --- a/x/distribution/keeper/keeper.go +++ b/x/distribution/keeper/keeper.go @@ -11,32 +11,39 @@ import ( "github.com/tendermint/tendermint/libs/log" ) -// keeper of the staking store +// Keeper of the distribution store type Keeper struct { - storeKey sdk.StoreKey - cdc *codec.Codec - paramSpace params.Subspace - bankKeeper types.BankKeeper - stakingKeeper types.StakingKeeper - feeCollectionKeeper types.FeeCollectionKeeper + storeKey sdk.StoreKey + cdc *codec.Codec + paramSpace params.Subspace + stakingKeeper types.StakingKeeper + supplyKeeper types.SupplyKeeper // codespace codespace sdk.CodespaceType + + feeCollectorName string // name of the FeeCollector ModuleAccount } -// create a new keeper -func NewKeeper(cdc *codec.Codec, key sdk.StoreKey, paramSpace params.Subspace, ck types.BankKeeper, - sk types.StakingKeeper, fck types.FeeCollectionKeeper, codespace sdk.CodespaceType) Keeper { - keeper := Keeper{ - storeKey: key, - cdc: cdc, - paramSpace: paramSpace.WithKeyTable(ParamKeyTable()), - bankKeeper: ck, - stakingKeeper: sk, - feeCollectionKeeper: fck, - codespace: codespace, +// NewKeeper creates a new distribution Keeper instance +func NewKeeper(cdc *codec.Codec, key sdk.StoreKey, paramSpace params.Subspace, + sk types.StakingKeeper, supplyKeeper types.SupplyKeeper, codespace sdk.CodespaceType, + feeCollectorName string) Keeper { + + // ensure distribution module account is set + if addr := supplyKeeper.GetModuleAddress(types.ModuleName); addr == nil { + panic(fmt.Sprintf("%s module account has not been set", types.ModuleName)) + } + + return Keeper{ + storeKey: key, + cdc: cdc, + paramSpace: paramSpace.WithKeyTable(ParamKeyTable()), + stakingKeeper: sk, + supplyKeeper: supplyKeeper, + codespace: codespace, + feeCollectorName: feeCollectorName, } - return keeper } // Logger returns a module-specific logger. @@ -110,8 +117,8 @@ func (k Keeper) WithdrawValidatorCommission(ctx sdk.Context, valAddr sdk.ValAddr if !commission.IsZero() { accAddr := sdk.AccAddress(valAddr) withdrawAddr := k.GetDelegatorWithdrawAddr(ctx, accAddr) - - if _, err := k.bankKeeper.AddCoins(ctx, withdrawAddr, commission); err != nil { + err := k.supplyKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, withdrawAddr, commission) + if err != nil { return nil, err } } @@ -125,3 +132,14 @@ func (k Keeper) WithdrawValidatorCommission(ctx sdk.Context, valAddr sdk.ValAddr return commission, nil } + +// GetTotalRewards returns the total amount of fee distribution rewards held in the store +func (k Keeper) GetTotalRewards(ctx sdk.Context) (totalRewards sdk.DecCoins) { + k.IterateValidatorOutstandingRewards(ctx, + func(_ sdk.ValAddress, rewards types.ValidatorOutstandingRewards) (stop bool) { + totalRewards = totalRewards.Add(rewards) + return false + }, + ) + return totalRewards +} diff --git a/x/distribution/keeper/keeper_test.go b/x/distribution/keeper/keeper_test.go index 925dd4988..e6019e396 100644 --- a/x/distribution/keeper/keeper_test.go +++ b/x/distribution/keeper/keeper_test.go @@ -30,12 +30,19 @@ func TestWithdrawValidatorCommission(t *testing.T) { sdk.NewDecCoinFromDec("stake", sdk.NewDec(3).Quo(sdk.NewDec(2))), } + // set module account coins + distrAcc := keeper.GetDistributionAccount(ctx) + distrAcc.SetCoins(sdk.NewCoins( + sdk.NewCoin("mytoken", sdk.NewInt(2)), + sdk.NewCoin("stake", sdk.NewInt(2)), + )) + keeper.supplyKeeper.SetModuleAccount(ctx, distrAcc) + // check initial balance balance := ak.GetAccount(ctx, sdk.AccAddress(valOpAddr3)).GetCoins() expTokens := sdk.TokensFromConsensusPower(1000) - require.Equal(t, sdk.Coins{ - sdk.NewCoin("stake", sdk.TokensFromConsensusPower(1000)), - }, balance) + expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens)) + require.Equal(t, expCoins, balance) // set outstanding rewards keeper.SetValidatorOutstandingRewards(ctx, valOpAddr3, valCommission) @@ -48,10 +55,10 @@ func TestWithdrawValidatorCommission(t *testing.T) { // check balance increase balance = ak.GetAccount(ctx, sdk.AccAddress(valOpAddr3)).GetCoins() - require.Equal(t, sdk.Coins{ + require.Equal(t, sdk.NewCoins( sdk.NewCoin("mytoken", sdk.NewInt(1)), sdk.NewCoin("stake", expTokens.AddRaw(1)), - }, balance) + ), balance) // check remainder remainder := keeper.GetValidatorAccumulatedCommission(ctx, valOpAddr3) @@ -62,3 +69,20 @@ func TestWithdrawValidatorCommission(t *testing.T) { require.True(t, true) } + +func TestGetTotalRewards(t *testing.T) { + ctx, _, keeper, _, _ := CreateTestInputDefault(t, false, 1000) + + valCommission := sdk.DecCoins{ + sdk.NewDecCoinFromDec("mytoken", sdk.NewDec(5).Quo(sdk.NewDec(4))), + sdk.NewDecCoinFromDec("stake", sdk.NewDec(3).Quo(sdk.NewDec(2))), + } + + keeper.SetValidatorOutstandingRewards(ctx, valOpAddr1, valCommission) + keeper.SetValidatorOutstandingRewards(ctx, valOpAddr2, valCommission) + + expectedRewards := valCommission.MulDec(sdk.NewDec(2)) + totalRewards := keeper.GetTotalRewards(ctx) + + require.Equal(t, expectedRewards, totalRewards) +} diff --git a/x/distribution/keeper/proposal_handler.go b/x/distribution/keeper/proposal_handler.go index 70b0bebaa..2bd491881 100644 --- a/x/distribution/keeper/proposal_handler.go +++ b/x/distribution/keeper/proposal_handler.go @@ -7,20 +7,14 @@ import ( "github.com/cosmos/cosmos-sdk/x/distribution/types" ) -// Handler for executing a passed community spend proposal +// HandleCommunityPoolSpendProposal is a handler for executing a passed community spend proposal func HandleCommunityPoolSpendProposal(ctx sdk.Context, k Keeper, p types.CommunityPoolSpendProposal) sdk.Error { - feePool := k.GetFeePool(ctx) - newPool, negative := feePool.CommunityPool.SafeSub(sdk.NewDecCoins(p.Amount)) - if negative { - return types.ErrBadDistribution(k.codespace) - } - feePool.CommunityPool = newPool - k.SetFeePool(ctx, feePool) - _, err := k.bankKeeper.AddCoins(ctx, p.Recipient, p.Amount) + err := k.DistributeFromFeePool(ctx, p.Amount, p.Recipient) if err != nil { return err } + logger := k.Logger(ctx) - logger.Info(fmt.Sprintf("Spent %s coins from the community pool to recipient %s", p.Amount, p.Recipient)) + logger.Info(fmt.Sprintf("transferred %s from the community pool to recipient %s", p.Amount, p.Recipient)) return nil } diff --git a/x/distribution/keeper/querier_test.go b/x/distribution/keeper/querier_test.go index 1709a9cb5..6fd969026 100644 --- a/x/distribution/keeper/querier_test.go +++ b/x/distribution/keeper/querier_test.go @@ -12,6 +12,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" ) const custom = "custom" @@ -138,6 +139,7 @@ func getQueriedCommunityPool(t *testing.T, ctx sdk.Context, cdc *codec.Codec, qu func TestQueries(t *testing.T) { cdc := codec.New() types.RegisterCodec(cdc) + supply.RegisterCodec(cdc) ctx, _, keeper, sk, _ := CreateTestInputDefault(t, false, 100) querier := NewQuerier(keeper) diff --git a/x/distribution/keeper/test_common.go b/x/distribution/keeper/test_common.go index 5393a81a3..e54655c91 100644 --- a/x/distribution/keeper/test_common.go +++ b/x/distribution/keeper/test_common.go @@ -18,6 +18,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/params" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" "github.com/cosmos/cosmos-sdk/x/distribution/types" ) @@ -66,6 +67,7 @@ func MakeTestCodec() *codec.Codec { bank.RegisterCodec(cdc) staking.RegisterCodec(cdc) auth.RegisterCodec(cdc) + supply.RegisterCodec(cdc) sdk.RegisterCodec(cdc) codec.RegisterCrypto(cdc) @@ -75,26 +77,26 @@ func MakeTestCodec() *codec.Codec { // test input with default values func CreateTestInputDefault(t *testing.T, isCheckTx bool, initPower int64) ( - sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) { + sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, types.SupplyKeeper) { communityTax := sdk.NewDecWithPrec(2, 2) - ctx, ak, _, dk, sk, fck, _ := CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax) - return ctx, ak, dk, sk, fck + ctx, ak, _, dk, sk, _, supplyKeeper := CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax) + return ctx, ak, dk, sk, supplyKeeper } // hogpodge of all sorts of input required for testing func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64, communityTax sdk.Dec) (sdk.Context, auth.AccountKeeper, bank.Keeper, - Keeper, staking.Keeper, DummyFeeCollectionKeeper, params.Keeper) { + Keeper, staking.Keeper, params.Keeper, types.SupplyKeeper) { - initCoins := sdk.TokensFromConsensusPower(initPower) + initTokens := sdk.TokensFromConsensusPower(initPower) keyDistr := sdk.NewKVStoreKey(types.StoreKey) keyStaking := sdk.NewKVStoreKey(staking.StoreKey) tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey) keyAcc := sdk.NewKVStoreKey(auth.StoreKey) - keyFeeCollection := sdk.NewKVStoreKey(auth.FeeStoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) keyParams := sdk.NewKVStoreKey(params.StoreKey) tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey) @@ -104,8 +106,8 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64, ms.MountStoreWithDB(keyDistr, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyStaking, sdk.StoreTypeTransient, nil) ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db) + ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyFeeCollection, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) @@ -118,23 +120,34 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64, ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, log.NewNopLogger()) accountKeeper := auth.NewAccountKeeper(cdc, keyAcc, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount) bankKeeper := bank.NewBaseKeeper(accountKeeper, pk.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) - sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, bankKeeper, pk.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) - sk.SetPool(ctx, staking.InitialPool()) + supplyKeeper := supply.NewKeeper(cdc, keySupply, accountKeeper, bankKeeper, supply.DefaultCodespace, + []string{auth.FeeCollectorName, types.ModuleName}, []string{}, []string{staking.NotBondedPoolName, staking.BondedPoolName}) + + sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, supplyKeeper, pk.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) sk.SetParams(ctx, staking.DefaultParams()) + keeper := NewKeeper(cdc, keyDistr, pk.Subspace(DefaultParamspace), sk, supplyKeeper, types.DefaultCodespace, auth.FeeCollectorName) + + initCoins := sdk.NewCoins(sdk.NewCoin(sk.BondDenom(ctx), initTokens)) + totalSupply := sdk.NewCoins(sdk.NewCoin(sk.BondDenom(ctx), initTokens.MulRaw(int64(len(TestAddrs))))) + supplyKeeper.SetSupply(ctx, supply.NewSupply(totalSupply)) + // fill all the addresses with some coins, set the loose pool tokens simultaneously for _, addr := range TestAddrs { - pool := sk.GetPool(ctx) - _, err := bankKeeper.AddCoins(ctx, addr, sdk.Coins{ - sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins), - }) + _, err := bankKeeper.AddCoins(ctx, addr, initCoins) require.Nil(t, err) - pool.NotBondedTokens = pool.NotBondedTokens.Add(initCoins) - sk.SetPool(ctx, pool) } - fck := DummyFeeCollectionKeeper{} - keeper := NewKeeper(cdc, keyDistr, pk.Subspace(DefaultParamspace), bankKeeper, sk, fck, types.DefaultCodespace) + // create module accounts + feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName, supply.Basic) + notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner) + distrAcc := supply.NewEmptyModuleAccount(types.ModuleName, supply.Basic) + + keeper.supplyKeeper.SetModuleAccount(ctx, feeCollectorAcc) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + keeper.supplyKeeper.SetModuleAccount(ctx, bondPool) + keeper.supplyKeeper.SetModuleAccount(ctx, distrAcc) // set the distribution hooks on staking sk.SetHooks(keeper.Hooks()) @@ -145,27 +158,5 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64, keeper.SetBaseProposerReward(ctx, sdk.NewDecWithPrec(1, 2)) keeper.SetBonusProposerReward(ctx, sdk.NewDecWithPrec(4, 2)) - return ctx, accountKeeper, bankKeeper, keeper, sk, fck, pk -} - -//__________________________________________________________________________________ -// fee collection keeper used only for testing -type DummyFeeCollectionKeeper struct{} - -var heldFees sdk.Coins -var _ types.FeeCollectionKeeper = DummyFeeCollectionKeeper{} - -// nolint -func (fck DummyFeeCollectionKeeper) AddCollectedFees(_ sdk.Context, in sdk.Coins) sdk.Coins { - fck.SetCollectedFees(heldFees.Add(in)) - return heldFees -} -func (fck DummyFeeCollectionKeeper) GetCollectedFees(_ sdk.Context) sdk.Coins { - return heldFees -} -func (fck DummyFeeCollectionKeeper) SetCollectedFees(in sdk.Coins) { - heldFees = in -} -func (fck DummyFeeCollectionKeeper) ClearCollectedFees(_ sdk.Context) { - heldFees = sdk.NewCoins() + return ctx, accountKeeper, bankKeeper, keeper, sk, pk, supplyKeeper } diff --git a/x/distribution/module.go b/x/distribution/module.go index 4fb6ccba6..6fe513ad6 100644 --- a/x/distribution/module.go +++ b/x/distribution/module.go @@ -14,6 +14,7 @@ import ( "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/x/distribution/client/cli" "github.com/cosmos/cosmos-sdk/x/distribution/client/rest" + "github.com/cosmos/cosmos-sdk/x/distribution/types" ) var ( @@ -67,14 +68,16 @@ func (AppModuleBasic) GetQueryCmd(cdc *codec.Codec) *cobra.Command { // app module type AppModule struct { AppModuleBasic - keeper Keeper + keeper Keeper + supplyKeeper types.SupplyKeeper } // NewAppModule creates a new AppModule object -func NewAppModule(keeper Keeper) AppModule { +func NewAppModule(keeper Keeper, supplyKeeper types.SupplyKeeper) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{}, keeper: keeper, + supplyKeeper: supplyKeeper, } } @@ -112,7 +115,7 @@ func (am AppModule) NewQuerierHandler() sdk.Querier { func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.ValidatorUpdate { var genesisState GenesisState ModuleCdc.MustUnmarshalJSON(data, &genesisState) - InitGenesis(ctx, am.keeper, genesisState) + InitGenesis(ctx, am.keeper, am.supplyKeeper, genesisState) return []abci.ValidatorUpdate{} } diff --git a/x/distribution/proposal_handler_test.go b/x/distribution/proposal_handler_test.go index 8d26753dc..d303a1ac5 100644 --- a/x/distribution/proposal_handler_test.go +++ b/x/distribution/proposal_handler_test.go @@ -13,6 +13,8 @@ import ( var ( delPk1 = ed25519.GenPrivKey().PubKey() delAddr1 = sdk.AccAddress(delPk1.Address()) + + amount = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1))) ) func testProposal(recipient sdk.AccAddress, amount sdk.Coins) types.CommunityPoolSpendProposal { @@ -25,34 +27,39 @@ func testProposal(recipient sdk.AccAddress, amount sdk.Coins) types.CommunityPoo } func TestProposalHandlerPassed(t *testing.T) { - ctx, accountKeeper, keeper, _, _ := CreateTestInputDefault(t, false, 10) + ctx, accountKeeper, keeper, _, supplyKeeper := CreateTestInputDefault(t, false, 10) recipient := delAddr1 - amount := sdk.NewCoin("stake", sdk.NewInt(1)) + + // add coins to the module account + macc := keeper.GetDistributionAccount(ctx) + err := macc.SetCoins(macc.GetCoins().Add(amount)) + require.NoError(t, err) + + supplyKeeper.SetModuleAccount(ctx, macc) account := accountKeeper.NewAccountWithAddress(ctx, recipient) require.True(t, account.GetCoins().IsZero()) accountKeeper.SetAccount(ctx, account) feePool := keeper.GetFeePool(ctx) - feePool.CommunityPool = sdk.DecCoins{sdk.NewDecCoinFromCoin(amount)} + feePool.CommunityPool = sdk.NewDecCoins(amount) keeper.SetFeePool(ctx, feePool) - tp := testProposal(recipient, sdk.NewCoins(amount)) + tp := testProposal(recipient, amount) hdlr := NewCommunityPoolSpendProposalHandler(keeper) require.NoError(t, hdlr(ctx, tp)) - require.Equal(t, accountKeeper.GetAccount(ctx, recipient).GetCoins(), sdk.NewCoins(amount)) + require.Equal(t, accountKeeper.GetAccount(ctx, recipient).GetCoins(), amount) } func TestProposalHandlerFailed(t *testing.T) { ctx, accountKeeper, keeper, _, _ := CreateTestInputDefault(t, false, 10) recipient := delAddr1 - amount := sdk.NewCoin("stake", sdk.NewInt(1)) account := accountKeeper.NewAccountWithAddress(ctx, recipient) require.True(t, account.GetCoins().IsZero()) accountKeeper.SetAccount(ctx, account) - tp := testProposal(recipient, sdk.NewCoins(amount)) + tp := testProposal(recipient, amount) hdlr := NewCommunityPoolSpendProposalHandler(keeper) require.Error(t, hdlr(ctx, tp)) require.True(t, accountKeeper.GetAccount(ctx, recipient).GetCoins().IsZero()) diff --git a/x/distribution/types/expected_keepers.go b/x/distribution/types/expected_keepers.go index 210592a2e..7afb5aa59 100644 --- a/x/distribution/types/expected_keepers.go +++ b/x/distribution/types/expected_keepers.go @@ -3,27 +3,26 @@ package types import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" + supplyexported "github.com/cosmos/cosmos-sdk/x/supply/exported" ) -// StakingKeeper expected staking keeper +// StakingKeeper expected staking keeper (noalias) type StakingKeeper interface { // iterate through validators by operator address, execute func for each validator IterateValidators(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) // iterate through bonded validators by operator address, execute func for each validator IterateBondedValidatorsByPower(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) // iterate through the consensus validator set of the last block by operator address, execute func for each validator IterateLastValidators(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) - Validator(sdk.Context, sdk.ValAddress) exported.ValidatorI // get a particular validator by operator address - ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) exported.ValidatorI // get a particular validator by consensus address - TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set - TotalTokens(sdk.Context) sdk.Int // total token supply + Validator(sdk.Context, sdk.ValAddress) stakingexported.ValidatorI // get a particular validator by operator address + ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingexported.ValidatorI // get a particular validator by consensus address // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) @@ -32,13 +31,13 @@ type StakingKeeper interface { // Delegation allows for getting a particular delegation for a given validator // and delegator outside the scope of the staking module. - Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) exported.DelegationI + Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingexported.DelegationI // MaxValidators returns the maximum amount of bonded validators MaxValidators(sdk.Context) uint16 IterateDelegations(ctx sdk.Context, delegator sdk.AccAddress, - fn func(index int64, delegation exported.DelegationI) (stop bool)) + fn func(index int64, delegation stakingexported.DelegationI) (stop bool)) GetLastTotalPower(ctx sdk.Context) sdk.Int GetLastValidatorPower(ctx sdk.Context, valAddr sdk.ValAddress) int64 @@ -46,7 +45,7 @@ type StakingKeeper interface { GetAllSDKDelegations(ctx sdk.Context) []staking.Delegation } -// StakingHooks event hooks for staking validator object +// StakingHooks event hooks for staking validator object (noalias) type StakingHooks interface { AfterValidatorCreated(ctx sdk.Context, valAddr sdk.ValAddress) // Must be called when a validator is created AfterValidatorRemoved(ctx sdk.Context, consAddr sdk.ConsAddress, valAddr sdk.ValAddress) // Must be called when a validator is deleted @@ -57,13 +56,15 @@ type StakingHooks interface { BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdk.Dec) } -// expected coin keeper -type BankKeeper interface { - AddCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Error) -} +// SupplyKeeper defines the expected supply Keeper (noalias) +type SupplyKeeper interface { + GetModuleAddress(name string) sdk.AccAddress + GetModuleAccount(ctx sdk.Context, name string) supplyexported.ModuleAccountI -// expected fee collection keeper -type FeeCollectionKeeper interface { - GetCollectedFees(ctx sdk.Context) sdk.Coins - ClearCollectedFees(ctx sdk.Context) + // TODO remove with genesis 2-phases refactor https://github.com/cosmos/cosmos-sdk/issues/2862 + SetModuleAccount(sdk.Context, supplyexported.ModuleAccountI) + + SendCoinsFromModuleToModule(ctx sdk.Context, senderModule string, recipientModule string, amt sdk.Coins) sdk.Error + SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) sdk.Error } diff --git a/x/distribution/types/keys.go b/x/distribution/types/keys.go index 21d182acb..aeb1e4d3f 100644 --- a/x/distribution/types/keys.go +++ b/x/distribution/types/keys.go @@ -2,7 +2,7 @@ package types const ( // ModuleName is the module name constant used in many places - ModuleName = "distr" + ModuleName = "distribution" // StoreKey is the store key string for distribution StoreKey = ModuleName diff --git a/x/auth/genaccounts/client/cli/genesis_accts.go b/x/genaccounts/client/cli/genesis_accts.go similarity index 97% rename from x/auth/genaccounts/client/cli/genesis_accts.go rename to x/genaccounts/client/cli/genesis_accts.go index 98518e172..6ae443c95 100644 --- a/x/auth/genaccounts/client/cli/genesis_accts.go +++ b/x/genaccounts/client/cli/genesis_accts.go @@ -11,7 +11,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/server" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth/genaccounts" + "github.com/cosmos/cosmos-sdk/x/genaccounts" "github.com/cosmos/cosmos-sdk/x/genutil" ) @@ -60,7 +60,7 @@ func AddGenesisAccountCmd(ctx *server.Context, cdc *codec.Codec, return err } - genAcc := genaccounts.NewGenesisAccountRaw(addr, coins, vestingAmt, vestingStart, vestingEnd) + genAcc := genaccounts.NewGenesisAccountRaw(addr, coins, vestingAmt, vestingStart, vestingEnd, "", "") if err := genAcc.Validate(); err != nil { return err } diff --git a/x/auth/genaccounts/codec.go b/x/genaccounts/codec.go similarity index 100% rename from x/auth/genaccounts/codec.go rename to x/genaccounts/codec.go diff --git a/x/auth/genaccounts/doc.go b/x/genaccounts/doc.go similarity index 100% rename from x/auth/genaccounts/doc.go rename to x/genaccounts/doc.go diff --git a/x/auth/genaccounts/expected.go b/x/genaccounts/expected.go similarity index 100% rename from x/auth/genaccounts/expected.go rename to x/genaccounts/expected.go diff --git a/x/auth/genaccounts/export.go b/x/genaccounts/export.go similarity index 100% rename from x/auth/genaccounts/export.go rename to x/genaccounts/export.go diff --git a/x/auth/genaccounts/genesis_account.go b/x/genaccounts/genesis_account.go similarity index 65% rename from x/auth/genaccounts/genesis_account.go rename to x/genaccounts/genesis_account.go index 35d15171f..bb5dc8ab7 100644 --- a/x/auth/genaccounts/genesis_account.go +++ b/x/genaccounts/genesis_account.go @@ -3,9 +3,13 @@ package genaccounts import ( "errors" "fmt" + "strings" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" + authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" + "github.com/cosmos/cosmos-sdk/x/supply" + supplyexported "github.com/cosmos/cosmos-sdk/x/supply/exported" ) // GenesisAccount is a struct for account initialization used exclusively during genesis @@ -21,9 +25,13 @@ type GenesisAccount struct { DelegatedVesting sdk.Coins `json:"delegated_vesting"` // delegated vesting coins at time of delegation StartTime int64 `json:"start_time"` // vesting start time (UNIX Epoch time) EndTime int64 `json:"end_time"` // vesting end time (UNIX Epoch time) + + // module account fields + ModuleName string `json:"module_name"` // name of the module account + ModulePermission string `json:"module_permission"` // permission of module account } -// validate the the VestingAccount parameters are possible +// Validate checks for errors on the vesting and module account parameters func (ga GenesisAccount) Validate() error { if !ga.OriginalVesting.IsZero() { if ga.OriginalVesting.IsAnyGT(ga.Coins) { @@ -33,12 +41,19 @@ func (ga GenesisAccount) Validate() error { return errors.New("vesting start-time cannot be before end-time") } } + + // don't allow blank (i.e just whitespaces) on the module name + if ga.ModuleName != "" && strings.TrimSpace(ga.ModuleName) == "" { + return errors.New("module account name cannot be blank") + } + return nil } -// NewGenesisAccount creates a new GenesisAccount object +// NewGenesisAccountRaw creates a new GenesisAccount object func NewGenesisAccountRaw(address sdk.AccAddress, coins, - vestingAmount sdk.Coins, vestingStartTime, vestingEndTime int64) GenesisAccount { + vestingAmount sdk.Coins, vestingStartTime, vestingEndTime int64, + module, permission string) GenesisAccount { return GenesisAccount{ Address: address, @@ -50,9 +65,12 @@ func NewGenesisAccountRaw(address sdk.AccAddress, coins, DelegatedVesting: sdk.Coins{}, // ignored StartTime: vestingStartTime, EndTime: vestingEndTime, + ModuleName: module, + ModulePermission: permission, } } +// NewGenesisAccount creates a GenesisAccount instance from a BaseAccount. func NewGenesisAccount(acc *auth.BaseAccount) GenesisAccount { return GenesisAccount{ Address: acc.Address, @@ -62,7 +80,8 @@ func NewGenesisAccount(acc *auth.BaseAccount) GenesisAccount { } } -func NewGenesisAccountI(acc auth.Account) (GenesisAccount, error) { +// NewGenesisAccountI creates a GenesisAccount instance from an Account interface. +func NewGenesisAccountI(acc authexported.Account) (GenesisAccount, error) { gacc := GenesisAccount{ Address: acc.GetAddress(), Coins: acc.GetCoins(), @@ -74,22 +93,26 @@ func NewGenesisAccountI(acc auth.Account) (GenesisAccount, error) { return gacc, err } - vacc, ok := acc.(auth.VestingAccount) - if ok { - gacc.OriginalVesting = vacc.GetOriginalVesting() - gacc.DelegatedFree = vacc.GetDelegatedFree() - gacc.DelegatedVesting = vacc.GetDelegatedVesting() - gacc.StartTime = vacc.GetStartTime() - gacc.EndTime = vacc.GetEndTime() + switch acc := acc.(type) { + case authexported.VestingAccount: + gacc.OriginalVesting = acc.GetOriginalVesting() + gacc.DelegatedFree = acc.GetDelegatedFree() + gacc.DelegatedVesting = acc.GetDelegatedVesting() + gacc.StartTime = acc.GetStartTime() + gacc.EndTime = acc.GetEndTime() + case supplyexported.ModuleAccountI: + gacc.ModuleName = acc.GetName() + gacc.ModulePermission = acc.GetPermission() } return gacc, nil } -// convert GenesisAccount to auth.Account +// ToAccount converts a GenesisAccount to an Account interface func (ga *GenesisAccount) ToAccount() auth.Account { bacc := auth.NewBaseAccount(ga.Address, ga.Coins.Sort(), nil, ga.AccountNumber, ga.Sequence) + // vesting accounts if !ga.OriginalVesting.IsZero() { baseVestingAcc := auth.NewBaseVestingAccount( bacc, ga.OriginalVesting, ga.DelegatedFree, @@ -106,6 +129,11 @@ func (ga *GenesisAccount) ToAccount() auth.Account { } } + // module accounts + if ga.ModuleName != "" { + return supply.NewModuleAccount(bacc, ga.ModuleName, ga.ModulePermission) + } + return bacc } diff --git a/x/auth/genaccounts/genesis_account_test.go b/x/genaccounts/genesis_account_test.go similarity index 72% rename from x/auth/genaccounts/genesis_account_test.go rename to x/genaccounts/genesis_account_test.go index dcd823199..de5aebbb3 100644 --- a/x/auth/genaccounts/genesis_account_test.go +++ b/x/genaccounts/genesis_account_test.go @@ -11,6 +11,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" + supplytypes "github.com/cosmos/cosmos-sdk/x/supply/types" ) func TestGenesisAccountValidate(t *testing.T) { @@ -22,13 +23,18 @@ func TestGenesisAccountValidate(t *testing.T) { }{ { "valid account", - NewGenesisAccountRaw(addr, sdk.NewCoins(), sdk.NewCoins(), 0, 0), + NewGenesisAccountRaw(addr, sdk.NewCoins(), sdk.NewCoins(), 0, 0, "", ""), + nil, + }, + { + "valid module account", + NewGenesisAccountRaw(addr, sdk.NewCoins(), sdk.NewCoins(), 0, 0, "mint", supplytypes.Minter), nil, }, { "invalid vesting amount", NewGenesisAccountRaw(addr, sdk.NewCoins(sdk.NewInt64Coin("stake", 50)), - sdk.NewCoins(sdk.NewInt64Coin("stake", 100)), 0, 0), + sdk.NewCoins(sdk.NewInt64Coin("stake", 100)), 0, 0, "", ""), errors.New("vesting amount cannot be greater than total amount"), }, { @@ -36,15 +42,20 @@ func TestGenesisAccountValidate(t *testing.T) { NewGenesisAccountRaw(addr, sdk.NewCoins(sdk.NewInt64Coin("uatom", 50), sdk.NewInt64Coin("eth", 50)), sdk.NewCoins(sdk.NewInt64Coin("uatom", 100), sdk.NewInt64Coin("eth", 20)), - 0, 0), + 0, 0, "", ""), errors.New("vesting amount cannot be greater than total amount"), }, { "invalid vesting times", NewGenesisAccountRaw(addr, sdk.NewCoins(sdk.NewInt64Coin("stake", 50)), - sdk.NewCoins(sdk.NewInt64Coin("stake", 50)), 1654668078, 1554668078), + sdk.NewCoins(sdk.NewInt64Coin("stake", 50)), 1654668078, 1554668078, "", ""), errors.New("vesting start-time cannot be before end-time"), }, + { + "invalid module account name", + NewGenesisAccountRaw(addr, sdk.NewCoins(), sdk.NewCoins(), 0, 0, " ", ""), + errors.New("module account name cannot be blank"), + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -57,6 +68,8 @@ func TestGenesisAccountValidate(t *testing.T) { func TestToAccount(t *testing.T) { priv := ed25519.GenPrivKey() addr := sdk.AccAddress(priv.PubKey().Address()) + + // base account authAcc := auth.NewBaseAccountWithAddress(addr) authAcc.SetCoins(sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 150))) genAcc := NewGenesisAccount(&authAcc) @@ -64,6 +77,7 @@ func TestToAccount(t *testing.T) { require.IsType(t, &auth.BaseAccount{}, acc) require.Equal(t, &authAcc, acc.(*auth.BaseAccount)) + // vesting account vacc := auth.NewContinuousVestingAccount( &authAcc, time.Now().Unix(), time.Now().Add(24*time.Hour).Unix(), ) @@ -72,4 +86,12 @@ func TestToAccount(t *testing.T) { acc = genAcc.ToAccount() require.IsType(t, &auth.ContinuousVestingAccount{}, acc) require.Equal(t, vacc, acc.(*auth.ContinuousVestingAccount)) + + // module account + macc := supplytypes.NewEmptyModuleAccount("mint", supplytypes.Minter) + genAcc, err = NewGenesisAccountI(macc) + require.NoError(t, err) + acc = genAcc.ToAccount() + require.IsType(t, &supplytypes.ModuleAccount{}, acc) + require.Equal(t, macc, acc.(*supplytypes.ModuleAccount)) } diff --git a/x/auth/genaccounts/genesis_state.go b/x/genaccounts/genesis_state.go similarity index 100% rename from x/auth/genaccounts/genesis_state.go rename to x/genaccounts/genesis_state.go diff --git a/x/auth/genaccounts/genesis_state_test.go b/x/genaccounts/genesis_state_test.go similarity index 100% rename from x/auth/genaccounts/genesis_state_test.go rename to x/genaccounts/genesis_state_test.go diff --git a/x/auth/genaccounts/init.go b/x/genaccounts/init.go similarity index 100% rename from x/auth/genaccounts/init.go rename to x/genaccounts/init.go diff --git a/x/auth/genaccounts/module.go b/x/genaccounts/module.go similarity index 100% rename from x/auth/genaccounts/module.go rename to x/genaccounts/module.go diff --git a/x/gov/deposit.go b/x/gov/deposit.go index bbaf3efdb..0059d693d 100644 --- a/x/gov/deposit.go +++ b/x/gov/deposit.go @@ -39,9 +39,8 @@ func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAdd return ErrAlreadyFinishedProposal(keeper.codespace, proposalID), false } - // Send coins from depositor's account to DepositedCoinsAccAddr account - // TODO: Don't use an account for this purpose; it's clumsy and prone to misuse. - err := keeper.ck.SendCoins(ctx, depositorAddr, DepositedCoinsAccAddr, depositAmount) + // update the governance module's account coins pool + err := keeper.supplyKeeper.SendCoinsFromAccountToModule(ctx, depositorAddr, types.ModuleName, depositAmount) if err != nil { return err, false } @@ -105,11 +104,12 @@ func (keeper Keeper) GetDepositsIterator(ctx sdk.Context, proposalID uint64) sdk func (keeper Keeper) RefundDeposits(ctx sdk.Context, proposalID uint64) { store := ctx.KVStore(keeper.storeKey) - keeper.IterateDeposits(ctx, proposalID, func(deposit Deposit) bool { - err := keeper.ck.SendCoins(ctx, DepositedCoinsAccAddr, deposit.Depositor, deposit.Amount) + keeper.IterateDeposits(ctx, proposalID, func(deposit types.Deposit) bool { + err := keeper.supplyKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, deposit.Depositor, deposit.Amount) if err != nil { panic(err) } + store.Delete(DepositKey(proposalID, deposit.Depositor)) return false }) @@ -119,8 +119,8 @@ func (keeper Keeper) RefundDeposits(ctx sdk.Context, proposalID uint64) { func (keeper Keeper) DeleteDeposits(ctx sdk.Context, proposalID uint64) { store := ctx.KVStore(keeper.storeKey) - keeper.IterateDeposits(ctx, proposalID, func(deposit Deposit) bool { - err := keeper.ck.SendCoins(ctx, DepositedCoinsAccAddr, BurnedDepositCoinsAccAddr, deposit.Amount) + keeper.IterateDeposits(ctx, proposalID, func(deposit types.Deposit) bool { + err := keeper.supplyKeeper.BurnCoins(ctx, types.ModuleName, deposit.Amount) if err != nil { panic(err) } diff --git a/x/gov/endblocker_test.go b/x/gov/endblocker_test.go index 4936f4ad6..f197ae85a 100644 --- a/x/gov/endblocker_test.go +++ b/x/gov/endblocker_test.go @@ -19,7 +19,6 @@ func TestTickExpiredDepositPeriod(t *testing.T) { input.mApp.BeginBlock(abci.RequestBeginBlock{Header: header}) ctx := input.mApp.BaseApp.NewContext(false, abci.Header{}) - input.keeper.ck.SetSendEnabled(ctx, true) govHandler := NewHandler(input.keeper) inactiveQueue := input.keeper.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time) @@ -69,7 +68,6 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) { input.mApp.BeginBlock(abci.RequestBeginBlock{Header: header}) ctx := input.mApp.BaseApp.NewContext(false, abci.Header{}) - input.keeper.ck.SetSendEnabled(ctx, true) govHandler := NewHandler(input.keeper) inactiveQueue := input.keeper.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time) @@ -138,7 +136,6 @@ func TestTickPassedDepositPeriod(t *testing.T) { input.mApp.BeginBlock(abci.RequestBeginBlock{Header: header}) ctx := input.mApp.BaseApp.NewContext(false, abci.Header{}) - input.keeper.ck.SetSendEnabled(ctx, true) govHandler := NewHandler(input.keeper) inactiveQueue := input.keeper.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time) @@ -188,7 +185,6 @@ func TestTickPassedVotingPeriod(t *testing.T) { input.mApp.BeginBlock(abci.RequestBeginBlock{Header: header}) ctx := input.mApp.BaseApp.NewContext(false, abci.Header{}) - input.keeper.ck.SetSendEnabled(ctx, true) govHandler := NewHandler(input.keeper) inactiveQueue := input.keeper.InactiveProposalQueueIterator(ctx, ctx.BlockHeader().Time) @@ -256,10 +252,13 @@ func TestProposalPassedEndblocker(t *testing.T) { valAddr := sdk.ValAddress(input.addrs[0]) - input.keeper.ck.SetSendEnabled(ctx, true) createValidators(t, stakingHandler, ctx, []sdk.ValAddress{valAddr}, []int64{10}) staking.EndBlocker(ctx, input.sk) + macc := input.keeper.GetGovernanceAccount(ctx) + require.NotNil(t, macc) + initialModuleAccCoins := macc.GetCoins() + proposal, err := input.keeper.SubmitProposal(ctx, testProposal()) require.NoError(t, err) @@ -268,6 +267,13 @@ func TestProposalPassedEndblocker(t *testing.T) { res := handler(ctx, newDepositMsg) require.True(t, res.IsOK()) + macc = input.keeper.GetGovernanceAccount(ctx) + require.NotNil(t, macc) + moduleAccCoins := macc.GetCoins() + + deposits := initialModuleAccCoins.Add(proposal.TotalDeposit).Add(proposalCoins) + require.True(t, moduleAccCoins.IsEqual(deposits)) + err = input.keeper.AddVote(ctx, proposal.ProposalID, input.addrs[0], OptionYes) require.NoError(t, err) @@ -276,6 +282,10 @@ func TestProposalPassedEndblocker(t *testing.T) { ctx = ctx.WithBlockHeader(newHeader) EndBlocker(ctx, input.keeper) + + macc = input.keeper.GetGovernanceAccount(ctx) + require.NotNil(t, macc) + require.True(t, macc.GetCoins().IsEqual(initialModuleAccCoins)) } func TestEndBlockerProposalHandlerFailed(t *testing.T) { @@ -294,7 +304,6 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) { valAddr := sdk.ValAddress(input.addrs[0]) - input.keeper.ck.SetSendEnabled(ctx, true) createValidators(t, stakingHandler, ctx, []sdk.ValAddress{valAddr}, []int64{10}) staking.EndBlocker(ctx, input.sk) diff --git a/x/gov/expected_keepers.go b/x/gov/expected_keepers.go index 15eb1e859..f53a49527 100644 --- a/x/gov/expected_keepers.go +++ b/x/gov/expected_keepers.go @@ -2,26 +2,31 @@ package gov import ( sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" + supplyexported "github.com/cosmos/cosmos-sdk/x/supply/exported" ) -// expected bank keeper -type BankKeeper interface { - GetCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins +// SupplyKeeper defines the supply Keeper for module accounts +type SupplyKeeper interface { + GetModuleAddress(name string) sdk.AccAddress + GetModuleAccount(ctx sdk.Context, name string) supplyexported.ModuleAccountI - // TODO remove once governance doesn't require use of accounts - SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) sdk.Error - SetSendEnabled(ctx sdk.Context, enabled bool) + // TODO remove with genesis 2-phases refactor https://github.com/cosmos/cosmos-sdk/issues/2862 + SetModuleAccount(sdk.Context, supplyexported.ModuleAccountI) + + SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) sdk.Error + BurnCoins(ctx sdk.Context, name string, amt sdk.Coins) sdk.Error } // StakingKeeper expected staking keeper (Validator and Delegator sets) type StakingKeeper interface { // iterate through bonded validators by operator address, execute func for each validator IterateBondedValidatorsByPower(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set IterateDelegations(ctx sdk.Context, delegator sdk.AccAddress, - fn func(index int64, delegation exported.DelegationI) (stop bool)) + fn func(index int64, delegation stakingexported.DelegationI) (stop bool)) } diff --git a/x/gov/genesis.go b/x/gov/genesis.go index ef9d1ae45..ea87444da 100644 --- a/x/gov/genesis.go +++ b/x/gov/genesis.go @@ -91,18 +91,29 @@ func ValidateGenesis(data GenesisState) error { } // InitGenesis - store genesis parameters -func InitGenesis(ctx sdk.Context, k Keeper, data GenesisState) { +func InitGenesis(ctx sdk.Context, k Keeper, supplyKeeper SupplyKeeper, data GenesisState) { k.setProposalID(ctx, data.StartingProposalID) k.setDepositParams(ctx, data.DepositParams) k.setVotingParams(ctx, data.VotingParams) k.setTallyParams(ctx, data.TallyParams) + + // check if the deposits pool account exists + moduleAcc := k.GetGovernanceAccount(ctx) + if moduleAcc == nil { + panic(fmt.Sprintf("%s module account has not been set", types.ModuleName)) + } + + var totalDeposits sdk.Coins for _, deposit := range data.Deposits { k.setDeposit(ctx, deposit.ProposalID, deposit.Depositor, deposit) + totalDeposits = totalDeposits.Add(deposit.Amount) } + for _, vote := range data.Votes { k.setVote(ctx, vote.ProposalID, vote.Voter, vote) } + for _, proposal := range data.Proposals { switch proposal.Status { case StatusDepositPeriod: @@ -112,6 +123,14 @@ func InitGenesis(ctx sdk.Context, k Keeper, data GenesisState) { } k.SetProposal(ctx, proposal) } + + // add coins if not provided on genesis + if moduleAcc.GetCoins().IsZero() { + if err := moduleAcc.SetCoins(totalDeposits); err != nil { + panic(err) + } + supplyKeeper.SetModuleAccount(ctx, moduleAcc) + } } // ExportGenesis - output genesis parameters diff --git a/x/gov/genesis_test.go b/x/gov/genesis_test.go index 871e34986..692a77b6a 100644 --- a/x/gov/genesis_test.go +++ b/x/gov/genesis_test.go @@ -85,7 +85,8 @@ func TestImportExportQueues(t *testing.T) { require.NoError(t, err) proposalID2 := proposal2.ProposalID - _, votingStarted := input.keeper.AddDeposit(ctx, proposalID2, input.addrs[0], input.keeper.GetDepositParams(ctx).MinDeposit) + err, votingStarted := input.keeper.AddDeposit(ctx, proposalID2, input.addrs[0], input.keeper.GetDepositParams(ctx).MinDeposit) + require.NoError(t, err) require.True(t, votingStarted) proposal1, ok := input.keeper.GetProposal(ctx, proposalID1) @@ -117,7 +118,9 @@ func TestImportExportQueues(t *testing.T) { require.True(t, proposal1.Status == StatusDepositPeriod) require.True(t, proposal2.Status == StatusVotingPeriod) - // Run the endblocker. Check to make sure that proposal1 is removed from state, and proposal2 is finished VotingPeriod. + require.Equal(t, input2.keeper.GetDepositParams(ctx2).MinDeposit, input2.keeper.GetGovernanceAccount(ctx2).GetCoins()) + + // Run the endblocker. Check to make sure that proposal1 is removed from state, and proposal2 is finished VotingPeriod. EndBlocker(ctx2, input2.keeper) proposal1, ok = input2.keeper.GetProposal(ctx2, proposalID1) diff --git a/x/gov/invariants.go b/x/gov/invariants.go new file mode 100644 index 000000000..1e9454978 --- /dev/null +++ b/x/gov/invariants.go @@ -0,0 +1,42 @@ +package gov + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +// RegisterInvariants registers all governance invariants +func RegisterInvariants(ir sdk.InvariantRegistry, keeper Keeper) { + ir.RegisterRoute(types.ModuleName, "module-account", ModuleAccountInvariant(keeper)) +} + +// AllInvariants runs all invariants of the governance module +func AllInvariants(keeper Keeper) sdk.Invariant { + return func(ctx sdk.Context) error { + return ModuleAccountInvariant(keeper)(ctx) + } +} + +// ModuleAccountInvariant checks that the module account coins reflects the sum of +// deposit amounts held on store +func ModuleAccountInvariant(keeper Keeper) sdk.Invariant { + return func(ctx sdk.Context) error { + var expectedDeposits sdk.Coins + + keeper.IterateAllDeposits(ctx, func(deposit types.Deposit) bool { + expectedDeposits = expectedDeposits.Add(deposit.Amount) + return false + }) + + macc := keeper.GetGovernanceAccount(ctx) + if !macc.GetCoins().IsEqual(expectedDeposits) { + return fmt.Errorf("deposits invariance:\n"+ + "\tgov ModuleAccount coins: %s\n"+ + "\tsum of deposit amounts: %s", macc.GetCoins(), expectedDeposits) + } + + return nil + } +} diff --git a/x/gov/keeper.go b/x/gov/keeper.go index c25105be3..826ef83cd 100644 --- a/x/gov/keeper.go +++ b/x/gov/keeper.go @@ -8,18 +8,11 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/params" + "github.com/cosmos/cosmos-sdk/x/supply/exported" - "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/libs/log" ) -// special governance addresses -var ( - // TODO: Find another way to implement this without using accounts, or find a cleaner way to implement it using accounts. - DepositedCoinsAccAddr = sdk.AccAddress(crypto.AddressHash([]byte("govDepositedCoins"))) - BurnedDepositCoinsAccAddr = sdk.AccAddress(crypto.AddressHash([]byte("govBurnedDepositCoins"))) -) - // Governance Keeper type Keeper struct { // The reference to the Param Keeper to get and set Global Params @@ -28,8 +21,8 @@ type Keeper struct { // The reference to the Paramstore to get and set gov specific params paramSpace params.Subspace - // The reference to the CoinKeeper to modify balances - ck BankKeeper + // The SupplyKeeper to reduce the supply of the network + supplyKeeper SupplyKeeper // The reference to the DelegationSet and ValidatorSet to get information about validators and delegators sk StakingKeeper @@ -54,9 +47,14 @@ type Keeper struct { // - and tallying the result of the vote. func NewKeeper( cdc *codec.Codec, key sdk.StoreKey, paramsKeeper params.Keeper, paramSpace params.Subspace, - ck BankKeeper, sk StakingKeeper, codespace sdk.CodespaceType, rtr Router, + supplyKeeper SupplyKeeper, sk StakingKeeper, codespace sdk.CodespaceType, rtr Router, ) Keeper { + // ensure governance module account is set + if addr := supplyKeeper.GetModuleAddress(types.ModuleName); addr == nil { + panic(fmt.Sprintf("%s module account has not been set", types.ModuleName)) + } + // It is vital to seal the governance proposal router here as to not allow // further handlers to be registered after the keeper is created since this // could create invalid or non-deterministic behavior. @@ -66,7 +64,7 @@ func NewKeeper( storeKey: key, paramsKeeper: paramsKeeper, paramSpace: paramSpace.WithKeyTable(ParamKeyTable()), - ck: ck, + supplyKeeper: supplyKeeper, sk: sk, cdc: cdc, codespace: codespace, @@ -79,6 +77,11 @@ func (keeper Keeper) Logger(ctx sdk.Context) log.Logger { return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName)) } +// GetGovernanceAccount returns the governance ModuleAccount +func (keeper Keeper) GetGovernanceAccount(ctx sdk.Context) exported.ModuleAccountI { + return keeper.supplyKeeper.GetModuleAccount(ctx, types.ModuleName) +} + // Params // Returns the current DepositParams from the global param store diff --git a/x/gov/keeper_test.go b/x/gov/keeper_test.go index ecee9eecf..8689bf55d 100644 --- a/x/gov/keeper_test.go +++ b/x/gov/keeper_test.go @@ -83,6 +83,7 @@ func TestActivateVotingPeriod(t *testing.T) { func TestDeposits(t *testing.T) { input := getMockApp(t, 2, GenesisState{}, nil) + SortAddresses(input.addrs) header := abci.Header{Height: input.mApp.LastBlockHeight() + 1} @@ -98,8 +99,8 @@ func TestDeposits(t *testing.T) { fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4))) fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5))) - addr0Initial := input.keeper.ck.GetCoins(ctx, input.addrs[0]) - addr1Initial := input.keeper.ck.GetCoins(ctx, input.addrs[1]) + addr0Initial := input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[0]).GetCoins() + addr1Initial := input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[1]).GetCoins() expTokens := sdk.TokensFromConsensusPower(42) require.Equal(t, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, expTokens)), addr0Initial) @@ -123,7 +124,7 @@ func TestDeposits(t *testing.T) { proposal, ok = input.keeper.GetProposal(ctx, proposalID) require.True(t, ok) require.Equal(t, fourStake, proposal.TotalDeposit) - require.Equal(t, addr0Initial.Sub(fourStake), input.keeper.ck.GetCoins(ctx, input.addrs[0])) + require.Equal(t, addr0Initial.Sub(fourStake), input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[0]).GetCoins()) // Check a second deposit from same address err, votingStarted = input.keeper.AddDeposit(ctx, proposalID, input.addrs[0], fiveStake) @@ -136,7 +137,7 @@ func TestDeposits(t *testing.T) { proposal, ok = input.keeper.GetProposal(ctx, proposalID) require.True(t, ok) require.Equal(t, fourStake.Add(fiveStake), proposal.TotalDeposit) - require.Equal(t, addr0Initial.Sub(fourStake).Sub(fiveStake), input.keeper.ck.GetCoins(ctx, input.addrs[0])) + require.Equal(t, addr0Initial.Sub(fourStake).Sub(fiveStake), input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[0]).GetCoins()) // Check third deposit from a new address err, votingStarted = input.keeper.AddDeposit(ctx, proposalID, input.addrs[1], fourStake) @@ -149,7 +150,7 @@ func TestDeposits(t *testing.T) { proposal, ok = input.keeper.GetProposal(ctx, proposalID) require.True(t, ok) require.Equal(t, fourStake.Add(fiveStake).Add(fourStake), proposal.TotalDeposit) - require.Equal(t, addr1Initial.Sub(fourStake), input.keeper.ck.GetCoins(ctx, input.addrs[1])) + require.Equal(t, addr1Initial.Sub(fourStake), input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[1]).GetCoins()) // Check that proposal moved to voting period proposal, ok = input.keeper.GetProposal(ctx, proposalID) @@ -177,8 +178,8 @@ func TestDeposits(t *testing.T) { input.keeper.RefundDeposits(ctx, proposalID) deposit, found = input.keeper.GetDeposit(ctx, proposalID, input.addrs[1]) require.False(t, found) - require.Equal(t, addr0Initial, input.keeper.ck.GetCoins(ctx, input.addrs[0])) - require.Equal(t, addr1Initial, input.keeper.ck.GetCoins(ctx, input.addrs[1])) + require.Equal(t, addr0Initial, input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[0]).GetCoins()) + require.Equal(t, addr1Initial, input.mApp.AccountKeeper.GetAccount(ctx, input.addrs[1]).GetCoins()) } diff --git a/x/gov/module.go b/x/gov/module.go index cc53f4e1b..bd50770dc 100644 --- a/x/gov/module.go +++ b/x/gov/module.go @@ -92,14 +92,16 @@ func (AppModuleBasic) GetQueryCmd(cdc *codec.Codec) *cobra.Command { // app module type AppModule struct { AppModuleBasic - keeper Keeper + keeper Keeper + supplyKeeper SupplyKeeper } // NewAppModule creates a new AppModule object -func NewAppModule(keeper Keeper) AppModule { +func NewAppModule(keeper Keeper, supplyKeeper SupplyKeeper) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{}, keeper: keeper, + supplyKeeper: supplyKeeper, } } @@ -109,7 +111,9 @@ func (AppModule) Name() string { } // register invariants -func (AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} +func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) { + RegisterInvariants(ir, am.keeper) +} // module message route name func (AppModule) Route() string { @@ -135,7 +139,7 @@ func (am AppModule) NewQuerierHandler() sdk.Querier { func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.ValidatorUpdate { var genesisState GenesisState types.ModuleCdc.MustUnmarshalJSON(data, &genesisState) - InitGenesis(ctx, am.keeper, genesisState) + InitGenesis(ctx, am.keeper, am.supplyKeeper, genesisState) return []abci.ValidatorUpdate{} } diff --git a/x/gov/test_common.go b/x/gov/test_common.go index ef329a39f..d5ec1628b 100644 --- a/x/gov/test_common.go +++ b/x/gov/test_common.go @@ -20,6 +20,14 @@ import ( "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/mock" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" +) + +var ( + valTokens = sdk.TokensFromConsensusPower(42) + initTokens = sdk.TokensFromConsensusPower(100000) + valCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, valTokens)) + initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) ) type testInput struct { @@ -36,30 +44,34 @@ func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []a mApp := mock.NewApp() staking.RegisterCodec(mApp.Cdc) - RegisterCodec(mApp.Cdc) + types.RegisterCodec(mApp.Cdc) + supply.RegisterCodec(mApp.Cdc) keyStaking := sdk.NewKVStoreKey(staking.StoreKey) tKeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey) keyGov := sdk.NewKVStoreKey(StoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) pk := mApp.ParamsKeeper rtr := NewRouter(). AddRoute(RouterKey, ProposalHandler) - ck := bank.NewBaseKeeper(mApp.AccountKeeper, mApp.ParamsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) - sk := staking.NewKeeper(mApp.Cdc, keyStaking, tKeyStaking, ck, pk.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) - keeper := NewKeeper(mApp.Cdc, keyGov, pk, pk.Subspace("testgov"), ck, sk, DefaultCodespace, rtr) + bk := bank.NewBaseKeeper(mApp.AccountKeeper, mApp.ParamsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) + + supplyKeeper := supply.NewKeeper(mApp.Cdc, keySupply, mApp.AccountKeeper, bk, supply.DefaultCodespace, + []string{}, []string{}, []string{types.ModuleName, staking.NotBondedPoolName, staking.BondedPoolName}) + sk := staking.NewKeeper(mApp.Cdc, keyStaking, tKeyStaking, supplyKeeper, pk.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) + + keeper := NewKeeper(mApp.Cdc, keyGov, pk, pk.Subspace("testgov"), supplyKeeper, sk, DefaultCodespace, rtr) mApp.Router().AddRoute(RouterKey, NewHandler(keeper)) mApp.QueryRouter().AddRoute(QuerierRoute, NewQuerier(keeper)) mApp.SetEndBlocker(getEndBlocker(keeper)) - mApp.SetInitChainer(getInitChainer(mApp, keeper, sk, mApp.AccountKeeper, genState)) + mApp.SetInitChainer(getInitChainer(mApp, keeper, sk, supplyKeeper, genAccs, genState)) - require.NoError(t, mApp.CompleteSetup(keyStaking, tKeyStaking, keyGov)) - - valTokens := sdk.TokensFromConsensusPower(42) + require.NoError(t, mApp.CompleteSetup(keyStaking, tKeyStaking, keyGov, keySupply)) var ( addrs []sdk.AccAddress @@ -68,8 +80,7 @@ func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []a ) if genAccs == nil || len(genAccs) == 0 { - genAccs, addrs, pubKeys, privKeys = mock.CreateGenAccounts(numGenAccs, - sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, valTokens)}) + genAccs, addrs, pubKeys, privKeys = mock.CreateGenAccounts(numGenAccs, valCoins) } mock.SetGenesis(mApp, genAccs) @@ -86,21 +97,29 @@ func getEndBlocker(keeper Keeper) sdk.EndBlocker { } // gov and staking initchainer -func getInitChainer(mapp *mock.App, keeper Keeper, stakingKeeper staking.Keeper, - accountKeeper staking.AccountKeeper, genState GenesisState) sdk.InitChainer { - +func getInitChainer(mapp *mock.App, keeper Keeper, stakingKeeper staking.Keeper, supplyKeeper supply.Keeper, accs []auth.Account, genState GenesisState) sdk.InitChainer { return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain { mapp.InitChainer(ctx, req) stakingGenesis := staking.DefaultGenesisState() - tokens := sdk.TokensFromConsensusPower(100000) - stakingGenesis.Pool.NotBondedTokens = tokens - validators := staking.InitGenesis(ctx, stakingKeeper, accountKeeper, stakingGenesis) + totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens.MulRaw(int64(len(mapp.GenesisAccounts))))) + supplyKeeper.SetSupply(ctx, supply.NewSupply(totalSupply)) + + // set module accounts + govAcc := supply.NewEmptyModuleAccount(types.ModuleName, supply.Burner) + notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner) + + supplyKeeper.SetModuleAccount(ctx, govAcc) + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + supplyKeeper.SetModuleAccount(ctx, bondPool) + + validators := staking.InitGenesis(ctx, stakingKeeper, mapp.AccountKeeper, supplyKeeper, stakingGenesis) if genState.IsEmpty() { - InitGenesis(ctx, keeper, DefaultGenesisState()) + InitGenesis(ctx, keeper, supplyKeeper, DefaultGenesisState()) } else { - InitGenesis(ctx, keeper, genState) + InitGenesis(ctx, keeper, supplyKeeper, genState) } return abci.ResponseInitChain{ Validators: validators, diff --git a/x/gov/types/vote.go b/x/gov/types/vote.go index 3dbf89a0f..abec4dc33 100644 --- a/x/gov/types/vote.go +++ b/x/gov/types/vote.go @@ -27,6 +27,9 @@ func (v Vote) String() string { type Votes []Vote func (v Votes) String() string { + if len(v) == 0 { + return "[]" + } out := fmt.Sprintf("Votes for Proposal %d:", v[0].ProposalID) for _, vot := range v { out += fmt.Sprintf("\n %s: %s", vot.Voter, vot.Option) diff --git a/x/ibc/app_test.go b/x/ibc/app_test.go index ca51ae9d8..4c2b330c8 100644 --- a/x/ibc/app_test.go +++ b/x/ibc/app_test.go @@ -9,6 +9,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/mock" + supplytypes "github.com/cosmos/cosmos-sdk/x/supply/types" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto/secp256k1" @@ -19,6 +20,8 @@ func getMockApp(t *testing.T) *mock.App { mapp := mock.NewApp() RegisterCodec(mapp.Cdc) + supplytypes.RegisterCodec(mapp.Cdc) + keyIBC := sdk.NewKVStoreKey("ibc") ibcMapper := NewMapper(mapp.Cdc, keyIBC, DefaultCodespace) bankKeeper := bank.NewBaseKeeper(mapp.AccountKeeper, diff --git a/x/mint/abci.go b/x/mint/abci.go index 6e38198be..3c4bc5fc5 100644 --- a/x/mint/abci.go +++ b/x/mint/abci.go @@ -12,16 +12,26 @@ func BeginBlocker(ctx sdk.Context, k Keeper) { params := k.GetParams(ctx) // recalculate inflation rate - totalSupply := k.TotalTokens(ctx) + totalStakingSupply := k.StakingTokenSupply(ctx) bondedRatio := k.BondedRatio(ctx) minter.Inflation = minter.NextInflationRate(params, bondedRatio) - minter.AnnualProvisions = minter.NextAnnualProvisions(params, totalSupply) + minter.AnnualProvisions = minter.NextAnnualProvisions(params, totalStakingSupply) k.SetMinter(ctx, minter) - // mint coins, add to collected fees, update supply + // mint coins, update supply mintedCoin := minter.BlockProvision(params) - k.AddCollectedFees(ctx, sdk.Coins{mintedCoin}) - k.InflateSupply(ctx, mintedCoin.Amount) + mintedCoins := sdk.NewCoins(mintedCoin) + + err := k.MintCoins(ctx, mintedCoins) + if err != nil { + panic(err) + } + + // send the minted coins to the fee collector account + err = k.AddCollectedFees(ctx, mintedCoins) + if err != nil { + panic(err) + } ctx.EventManager().EmitEvent( sdk.NewEvent( diff --git a/x/mint/genesis.go b/x/mint/genesis.go index 65eb86824..534675607 100644 --- a/x/mint/genesis.go +++ b/x/mint/genesis.go @@ -26,7 +26,7 @@ func DefaultGenesisState() GenesisState { } } -// new mint genesis +// InitGenesis new mint genesis func InitGenesis(ctx sdk.Context, keeper Keeper, data GenesisState) { keeper.SetMinter(ctx, data.Minter) keeper.SetParams(ctx, data.Params) diff --git a/x/mint/internal/keeper/keeper.go b/x/mint/internal/keeper/keeper.go index 8d8047e6d..bf44060db 100644 --- a/x/mint/internal/keeper/keeper.go +++ b/x/mint/internal/keeper/keeper.go @@ -11,28 +11,34 @@ import ( "github.com/cosmos/cosmos-sdk/x/params" ) -// keeper of the staking store +// Keeper of the mint store type Keeper struct { - storeKey sdk.StoreKey - cdc *codec.Codec - paramSpace params.Subspace - sk types.StakingKeeper - fck types.FeeCollectionKeeper + cdc *codec.Codec + storeKey sdk.StoreKey + paramSpace params.Subspace + sk types.StakingKeeper + supplyKeeper types.SupplyKeeper + feeCollectorName string } +// NewKeeper creates a new mint Keeper instance func NewKeeper( cdc *codec.Codec, key sdk.StoreKey, paramSpace params.Subspace, - sk types.StakingKeeper, fck types.FeeCollectionKeeper, -) Keeper { + sk types.StakingKeeper, supplyKeeper types.SupplyKeeper, feeCollectorName string) Keeper { - keeper := Keeper{ - storeKey: key, - cdc: cdc, - paramSpace: paramSpace.WithKeyTable(types.ParamKeyTable()), - sk: sk, - fck: fck, + // ensure mint module account is set + if addr := supplyKeeper.GetModuleAddress(types.ModuleName); addr == nil { + panic("the mint module account has not been set") + } + + return Keeper{ + cdc: cdc, + storeKey: key, + paramSpace: paramSpace.WithKeyTable(types.ParamKeyTable()), + sk: sk, + supplyKeeper: supplyKeeper, + feeCollectorName: feeCollectorName, } - return keeper } //______________________________________________________________________ @@ -61,30 +67,6 @@ func (k Keeper) SetMinter(ctx sdk.Context, minter types.Minter) { store.Set(types.MinterKey, b) } -// TotalTokens implements an alias call to the underlying staking keeper's -// TotalTokens to be used in BeginBlocker. -func (k Keeper) TotalTokens(ctx sdk.Context) sdk.Int { - return k.sk.TotalTokens(ctx) -} - -// BondedRatio implements an alias call to the underlying staking keeper's -// BondedRatio to be used in BeginBlocker. -func (k Keeper) BondedRatio(ctx sdk.Context) sdk.Dec { - return k.sk.BondedRatio(ctx) -} - -// InflateSupply implements an alias call to the underlying staking keeper's -// InflateSupply to be used in BeginBlocker. -func (k Keeper) InflateSupply(ctx sdk.Context, newTokens sdk.Int) { - k.sk.InflateSupply(ctx, newTokens) -} - -// AddCollectedFees implements an alias call to the underlying staking keeper's -// AddCollectedFees to be used in BeginBlocker. -func (k Keeper) AddCollectedFees(ctx sdk.Context, fees sdk.Coins) sdk.Coins { - return k.fck.AddCollectedFees(ctx, fees) -} - //______________________________________________________________________ // GetParams returns the total set of minting parameters. @@ -97,3 +79,29 @@ func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) { func (k Keeper) SetParams(ctx sdk.Context, params types.Params) { k.paramSpace.SetParamSet(ctx, ¶ms) } + +//______________________________________________________________________ + +// StakingTokenSupply implements an alias call to the underlying staking keeper's +// StakingTokenSupply to be used in BeginBlocker. +func (k Keeper) StakingTokenSupply(ctx sdk.Context) sdk.Int { + return k.sk.StakingTokenSupply(ctx) +} + +// BondedRatio implements an alias call to the underlying staking keeper's +// BondedRatio to be used in BeginBlocker. +func (k Keeper) BondedRatio(ctx sdk.Context) sdk.Dec { + return k.sk.BondedRatio(ctx) +} + +// MintCoins implements an alias call to the underlying supply keeper's +// MintCoins to be used in BeginBlocker. +func (k Keeper) MintCoins(ctx sdk.Context, newCoins sdk.Coins) sdk.Error { + return k.supplyKeeper.MintCoins(ctx, types.ModuleName, newCoins) +} + +// AddCollectedFees implements an alias call to the underlying supply keeper's +// AddCollectedFees to be used in BeginBlocker. +func (k Keeper) AddCollectedFees(ctx sdk.Context, fees sdk.Coins) sdk.Error { + return k.supplyKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, k.feeCollectorName, fees) +} diff --git a/x/mint/internal/keeper/test_common.go b/x/mint/internal/keeper/test_common.go index 3aa27cff0..f9be3d040 100644 --- a/x/mint/internal/keeper/test_common.go +++ b/x/mint/internal/keeper/test_common.go @@ -21,6 +21,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/mint/internal/types" "github.com/cosmos/cosmos-sdk/x/params" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" ) type testInput struct { @@ -33,36 +34,48 @@ func newTestInput(t *testing.T) testInput { db := dbm.NewMemDB() keyAcc := sdk.NewKVStoreKey(auth.StoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) keyStaking := sdk.NewKVStoreKey(staking.StoreKey) tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey) keyParams := sdk.NewKVStoreKey(params.StoreKey) tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey) - keyFeeCollection := sdk.NewKVStoreKey(auth.FeeStoreKey) keyMint := sdk.NewKVStoreKey(types.StoreKey) ms := store.NewCommitMultiStore(db) ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyStaking, sdk.StoreTypeTransient, nil) ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db) - ms.MountStoreWithDB(keyFeeCollection, sdk.StoreTypeIAVL, db) + ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyMint, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) err := ms.LoadLatestVersion() require.Nil(t, err) + ctx := sdk.NewContext(ms, abci.Header{Time: time.Unix(0, 0)}, false, log.NewTMLogger(os.Stdout)) + paramsKeeper := params.NewKeeper(types.ModuleCdc, keyParams, tkeyParams, params.DefaultCodespace) - feeCollectionKeeper := auth.NewFeeCollectionKeeper(types.ModuleCdc, keyFeeCollection) accountKeeper := auth.NewAccountKeeper(types.ModuleCdc, keyAcc, paramsKeeper.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount) bankKeeper := bank.NewBaseKeeper(accountKeeper, paramsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) - stakingKeeper := staking.NewKeeper( - types.ModuleCdc, keyStaking, tkeyStaking, bankKeeper, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace, - ) - mintKeeper := NewKeeper( - types.ModuleCdc, keyMint, paramsKeeper.Subspace(types.DefaultParamspace), &stakingKeeper, feeCollectionKeeper, - ) + supplyKeeper := supply.NewKeeper(types.ModuleCdc, keySupply, accountKeeper, bankKeeper, supply.DefaultCodespace, + []string{auth.FeeCollectorName}, []string{types.ModuleName}, []string{staking.NotBondedPoolName, staking.BondedPoolName}) + supplyKeeper.SetSupply(ctx, supply.NewSupply(sdk.Coins{})) - ctx := sdk.NewContext(ms, abci.Header{Time: time.Unix(0, 0)}, false, log.NewTMLogger(os.Stdout)) + stakingKeeper := staking.NewKeeper( + types.ModuleCdc, keyStaking, tkeyStaking, supplyKeeper, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace, + ) + mintKeeper := NewKeeper(types.ModuleCdc, keyMint, paramsKeeper.Subspace(types.DefaultParamspace), &stakingKeeper, supplyKeeper, auth.FeeCollectorName) + + // set module accounts + feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName, supply.Basic) + minterAcc := supply.NewEmptyModuleAccount(types.ModuleName, supply.Minter) + notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner) + + supplyKeeper.SetModuleAccount(ctx, feeCollectorAcc) + supplyKeeper.SetModuleAccount(ctx, minterAcc) + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + supplyKeeper.SetModuleAccount(ctx, bondPool) mintKeeper.SetParams(ctx, types.DefaultParams()) mintKeeper.SetMinter(ctx, types.DefaultInitialMinter()) diff --git a/x/mint/internal/types/expected_keepers.go b/x/mint/internal/types/expected_keepers.go index 99a961ee7..564a0136b 100644 --- a/x/mint/internal/types/expected_keepers.go +++ b/x/mint/internal/types/expected_keepers.go @@ -2,16 +2,23 @@ package types // noalias import ( sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/exported" ) -// expected staking keeper +// StakingKeeper defines the expected staking keeper type StakingKeeper interface { - TotalTokens(ctx sdk.Context) sdk.Int + StakingTokenSupply(ctx sdk.Context) sdk.Int BondedRatio(ctx sdk.Context) sdk.Dec - InflateSupply(ctx sdk.Context, newTokens sdk.Int) } -// expected fee collection keeper interface -type FeeCollectionKeeper interface { - AddCollectedFees(sdk.Context, sdk.Coins) sdk.Coins +// SupplyKeeper defines the expected supply keeper +type SupplyKeeper interface { + GetModuleAddress(name string) sdk.AccAddress + + // TODO remove with genesis 2-phases refactor https://github.com/cosmos/cosmos-sdk/issues/2862 + SetModuleAccount(sdk.Context, exported.ModuleAccountI) + + SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + SendCoinsFromModuleToModule(ctx sdk.Context, senderModule, recipientModule string, amt sdk.Coins) sdk.Error + MintCoins(ctx sdk.Context, name string, amt sdk.Coins) sdk.Error } diff --git a/x/mock/app.go b/x/mock/app.go index 75deed6a5..591b3110d 100644 --- a/x/mock/app.go +++ b/x/mock/app.go @@ -28,17 +28,15 @@ const chainID = "" // capabilities aren't needed for testing. type App struct { *bam.BaseApp - Cdc *codec.Codec // Cdc is public since the codec is passed into the module anyways - KeyMain *sdk.KVStoreKey - KeyAccount *sdk.KVStoreKey - KeyFeeCollection *sdk.KVStoreKey - KeyParams *sdk.KVStoreKey - TKeyParams *sdk.TransientStoreKey + Cdc *codec.Codec // Cdc is public since the codec is passed into the module anyways + KeyMain *sdk.KVStoreKey + KeyAccount *sdk.KVStoreKey + KeyParams *sdk.KVStoreKey + TKeyParams *sdk.TransientStoreKey // TODO: Abstract this out from not needing to be auth specifically - AccountKeeper auth.AccountKeeper - FeeCollectionKeeper auth.FeeCollectionKeeper - ParamsKeeper params.Keeper + AccountKeeper auth.AccountKeeper + ParamsKeeper params.Keeper GenesisAccounts []auth.Account TotalCoinsSupply sdk.Coins @@ -59,30 +57,27 @@ func NewApp() *App { Cdc: cdc, KeyMain: sdk.NewKVStoreKey(bam.MainStoreKey), KeyAccount: sdk.NewKVStoreKey(auth.StoreKey), - KeyFeeCollection: sdk.NewKVStoreKey("fee"), KeyParams: sdk.NewKVStoreKey("params"), TKeyParams: sdk.NewTransientStoreKey("transient_params"), TotalCoinsSupply: sdk.NewCoins(), } + // define keepers app.ParamsKeeper = params.NewKeeper(app.Cdc, app.KeyParams, app.TKeyParams, params.DefaultCodespace) - // Define the accountKeeper app.AccountKeeper = auth.NewAccountKeeper( app.Cdc, app.KeyAccount, app.ParamsKeeper.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount, ) - app.FeeCollectionKeeper = auth.NewFeeCollectionKeeper( - app.Cdc, - app.KeyFeeCollection, - ) + + supplyKeeper := auth.NewDummySupplyKeeper(app.AccountKeeper) // Initialize the app. The chainers and blockers can be overwritten before // calling complete setup. app.SetInitChainer(app.InitChainer) - app.SetAnteHandler(auth.NewAnteHandler(app.AccountKeeper, app.FeeCollectionKeeper, auth.DefaultSigVerificationGasConsumer)) + app.SetAnteHandler(auth.NewAnteHandler(app.AccountKeeper, supplyKeeper, auth.DefaultSigVerificationGasConsumer)) // Not sealing for custom extension @@ -94,7 +89,7 @@ func NewApp() *App { func (app *App) CompleteSetup(newKeys ...sdk.StoreKey) error { newKeys = append( newKeys, - app.KeyMain, app.KeyAccount, app.KeyParams, app.TKeyParams, app.KeyFeeCollection, + app.KeyMain, app.KeyAccount, app.KeyParams, app.TKeyParams, ) for _, key := range newKeys { @@ -116,6 +111,7 @@ func (app *App) CompleteSetup(newKeys ...sdk.StoreKey) error { // InitChainer performs custom logic for initialization. // nolint: errcheck func (app *App) InitChainer(ctx sdk.Context, _ abci.RequestInitChain) abci.ResponseInitChain { + // Load the genesis accounts for _, genacc := range app.GenesisAccounts { acc := app.AccountKeeper.NewAccountWithAddress(ctx, genacc.GetAddress()) @@ -123,7 +119,7 @@ func (app *App) InitChainer(ctx sdk.Context, _ abci.RequestInitChain) abci.Respo app.AccountKeeper.SetAccount(ctx, acc) } - auth.InitGenesis(ctx, app.AccountKeeper, app.FeeCollectionKeeper, auth.DefaultGenesisState()) + auth.InitGenesis(ctx, app.AccountKeeper, auth.DefaultGenesisState()) return abci.ResponseInitChain{} } diff --git a/x/mock/app_test.go b/x/mock/app_test.go index 7a2b6adfd..4f555c029 100644 --- a/x/mock/app_test.go +++ b/x/mock/app_test.go @@ -8,6 +8,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" + supplytypes "github.com/cosmos/cosmos-sdk/x/supply/types" ) const msgRoute = "testMsg" @@ -51,6 +52,7 @@ func getMockApp(t *testing.T) *App { func TestCheckAndDeliverGenTx(t *testing.T) { mApp := getMockApp(t) mApp.Cdc.RegisterConcrete(testMsg{}, "mock/testMsg", nil) + supplytypes.RegisterCodec(mApp.Cdc) SetGenesis(mApp, accs) ctxCheck := mApp.BaseApp.NewContext(true, abci.Header{}) @@ -90,6 +92,7 @@ func TestCheckAndDeliverGenTx(t *testing.T) { func TestCheckGenTx(t *testing.T) { mApp := getMockApp(t) mApp.Cdc.RegisterConcrete(testMsg{}, "mock/testMsg", nil) + supplytypes.RegisterCodec(mApp.Cdc) SetGenesis(mApp, accs) diff --git a/x/simulation/params.go b/x/simulation/params.go index 643360461..526f1972f 100644 --- a/x/simulation/params.go +++ b/x/simulation/params.go @@ -9,6 +9,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" ) +// nolint const ( // Minimum time per block minTimePerBlock int64 = 10000 / 2 @@ -148,6 +149,7 @@ var ( } ) +// TODO add description type ( AppParams map[string]json.RawMessage ParamSimulator func(r *rand.Rand) diff --git a/x/simulation/rand_util.go b/x/simulation/rand_util.go index b46b0fb7d..ce2a8c4c1 100644 --- a/x/simulation/rand_util.go +++ b/x/simulation/rand_util.go @@ -36,6 +36,7 @@ func RandStringOfLength(r *rand.Rand, n int) string { return string(b) } +// get a rand positive sdk.Int func RandPositiveInt(r *rand.Rand, max sdk.Int) (sdk.Int, error) { if !max.GT(sdk.OneInt()) { return sdk.Int{}, errors.New("max too small") diff --git a/x/simulation/util.go b/x/simulation/util.go index 49f6bc544..4d23f9f3d 100644 --- a/x/simulation/util.go +++ b/x/simulation/util.go @@ -63,7 +63,7 @@ func getBlockSize(r *rand.Rand, params Params, // PeriodicInvariants returns an array of wrapped Invariants. Where each // invariant function is only executed periodically defined by period and offset. -func PeriodicInvariants(invariants []sdk.Invariant, period int, offset int) []sdk.Invariant { +func PeriodicInvariants(invariants []sdk.Invariant, period, offset int) []sdk.Invariant { var outInvariants []sdk.Invariant for _, invariant := range invariants { outInvariant := func(ctx sdk.Context) error { diff --git a/x/slashing/abci_test.go b/x/slashing/abci_test.go index 51bf6feb2..5edea6309 100644 --- a/x/slashing/abci_test.go +++ b/x/slashing/abci_test.go @@ -24,7 +24,7 @@ func TestBeginBlocker(t *testing.T) { staking.EndBlocker(ctx, sk) require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(addr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.NewCoins(sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))), ) require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens()) diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index 44a89daae..40096b1aa 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -13,6 +13,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/mock" "github.com/cosmos/cosmos-sdk/x/staking" "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/cosmos/cosmos-sdk/x/supply" ) var ( @@ -27,21 +28,25 @@ func getMockApp(t *testing.T) (*mock.App, staking.Keeper, Keeper) { RegisterCodec(mapp.Cdc) staking.RegisterCodec(mapp.Cdc) + supply.RegisterCodec(mapp.Cdc) keyStaking := sdk.NewKVStoreKey(staking.StoreKey) tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey) keySlashing := sdk.NewKVStoreKey(StoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) bankKeeper := bank.NewBaseKeeper(mapp.AccountKeeper, mapp.ParamsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) - stakingKeeper := staking.NewKeeper(mapp.Cdc, keyStaking, tkeyStaking, bankKeeper, mapp.ParamsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) + supplyKeeper := supply.NewKeeper(mapp.Cdc, keySupply, mapp.AccountKeeper, bankKeeper, supply.DefaultCodespace, + []string{auth.FeeCollectorName}, []string{}, []string{staking.NotBondedPoolName, staking.BondedPoolName}) + stakingKeeper := staking.NewKeeper(mapp.Cdc, keyStaking, tkeyStaking, supplyKeeper, mapp.ParamsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) keeper := NewKeeper(mapp.Cdc, keySlashing, stakingKeeper, mapp.ParamsKeeper.Subspace(DefaultParamspace), DefaultCodespace) mapp.Router().AddRoute(staking.RouterKey, staking.NewHandler(stakingKeeper)) mapp.Router().AddRoute(RouterKey, NewHandler(keeper)) mapp.SetEndBlocker(getEndBlocker(stakingKeeper)) - mapp.SetInitChainer(getInitChainer(mapp, stakingKeeper, mapp.AccountKeeper)) + mapp.SetInitChainer(getInitChainer(mapp, stakingKeeper, mapp.AccountKeeper, supplyKeeper)) - require.NoError(t, mapp.CompleteSetup(keyStaking, tkeyStaking, keySlashing)) + require.NoError(t, mapp.CompleteSetup(keyStaking, tkeyStaking, keySupply, keySlashing)) return mapp, stakingKeeper, keeper } @@ -57,13 +62,20 @@ func getEndBlocker(keeper staking.Keeper) sdk.EndBlocker { } // overwrite the mock init chainer -func getInitChainer(mapp *mock.App, keeper staking.Keeper, accountKeeper types.AccountKeeper) sdk.InitChainer { +func getInitChainer(mapp *mock.App, keeper staking.Keeper, accountKeeper types.AccountKeeper, supplyKeeper types.SupplyKeeper) sdk.InitChainer { return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain { + // set module accounts + feeCollector := supply.NewEmptyModuleAccount(auth.FeeCollectorName, supply.Basic) + notBondedPool := supply.NewEmptyModuleAccount(types.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(types.BondedPoolName, supply.Burner) + + supplyKeeper.SetModuleAccount(ctx, feeCollector) + supplyKeeper.SetModuleAccount(ctx, bondPool) + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + mapp.InitChainer(ctx, req) stakingGenesis := staking.DefaultGenesisState() - tokens := sdk.TokensFromConsensusPower(100000) - stakingGenesis.Pool.NotBondedTokens = tokens - validators := staking.InitGenesis(ctx, keeper, accountKeeper, stakingGenesis) + validators := staking.InitGenesis(ctx, keeper, accountKeeper, supplyKeeper, stakingGenesis) return abci.ResponseInitChain{ Validators: validators, } diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go index bd3ab2f30..854a1d140 100644 --- a/x/slashing/handler_test.go +++ b/x/slashing/handler_test.go @@ -25,7 +25,7 @@ func TestCannotUnjailUnlessJailed(t *testing.T) { require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(addr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))}, ) require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens()) @@ -50,7 +50,7 @@ func TestCannotUnjailUnlessMeetMinSelfDelegation(t *testing.T) { require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(addr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))}, ) unbondAmt := sdk.NewCoin(sk.GetParams(ctx).BondDenom, sdk.OneInt()) diff --git a/x/slashing/keeper.go b/x/slashing/keeper.go index cd0bad003..6d112a512 100644 --- a/x/slashing/keeper.go +++ b/x/slashing/keeper.go @@ -69,7 +69,7 @@ func (k Keeper) HandleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio // Reject evidence if the double-sign is too old if age > k.MaxEvidenceAge(ctx) { logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, age of %d past max age of %d", - pubkey.Address(), infractionHeight, age, k.MaxEvidenceAge(ctx))) + sdk.ConsAddress(pubkey.Address()), infractionHeight, age, k.MaxEvidenceAge(ctx))) return } @@ -90,12 +90,12 @@ func (k Keeper) HandleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio // validator is already tombstoned if signInfo.Tombstoned { - logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, validator already tombstoned", pubkey.Address(), infractionHeight)) + logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, validator already tombstoned", sdk.ConsAddress(pubkey.Address()), infractionHeight)) return } // double sign confirmed - logger.Info(fmt.Sprintf("Confirmed double sign from %s at height %d, age of %d", pubkey.Address(), infractionHeight, age)) + logger.Info(fmt.Sprintf("Confirmed double sign from %s at height %d, age of %d", sdk.ConsAddress(pubkey.Address()), infractionHeight, age)) // We need to retrieve the stake distribution which signed the block, so we subtract ValidatorUpdateDelay from the evidence height. // Note that this *can* result in a negative "distributionHeight", up to -ValidatorUpdateDelay, @@ -151,7 +151,7 @@ func (k Keeper) HandleValidatorSignature(ctx sdk.Context, addr crypto.Address, p consAddr := sdk.ConsAddress(addr) pubkey, err := k.getPubkey(ctx, addr) if err != nil { - panic(fmt.Sprintf("Validator consensus-address %v not found", consAddr)) + panic(fmt.Sprintf("Validator consensus-address %v not found", consAddr.String())) } // fetch signing info @@ -193,7 +193,7 @@ func (k Keeper) HandleValidatorSignature(ctx sdk.Context, addr crypto.Address, p ), ) - logger.Info(fmt.Sprintf("Absent validator %s (%v) at height %d, %d missed, threshold %d", addr, pubkey, height, signInfo.MissedBlocksCounter, k.MinSignedPerWindow(ctx))) + logger.Info(fmt.Sprintf("Absent validator %s (%s) at height %d, %d missed, threshold %d", addr, pubkey, height, signInfo.MissedBlocksCounter, k.MinSignedPerWindow(ctx))) } minHeight := signInfo.StartHeight + k.SignedBlocksWindow(ctx) @@ -206,7 +206,7 @@ func (k Keeper) HandleValidatorSignature(ctx sdk.Context, addr crypto.Address, p // Downtime confirmed: slash and jail the validator logger.Info(fmt.Sprintf("Validator %s past min height of %d and below signed blocks threshold of %d", - pubkey.Address(), minHeight, k.MinSignedPerWindow(ctx))) + sdk.ConsAddress(pubkey.Address()), minHeight, k.MinSignedPerWindow(ctx))) // We need to retrieve the stake distribution which signed the block, so we subtract ValidatorUpdateDelay from the evidence height, // and subtract an additional 1 since this is the LastCommit. @@ -236,7 +236,7 @@ func (k Keeper) HandleValidatorSignature(ctx sdk.Context, addr crypto.Address, p } else { // Validator was (a) not found or (b) already jailed, don't slash logger.Info(fmt.Sprintf("Validator %s would have been slashed for downtime, but was either not found in store or already jailed", - pubkey.Address())) + sdk.ConsAddress(pubkey.Address()))) } } @@ -254,7 +254,7 @@ func (k Keeper) getPubkey(ctx sdk.Context, address crypto.Address) (crypto.PubKe var pubkey crypto.PubKey err := k.cdc.UnmarshalBinaryLengthPrefixed(store.Get(types.GetAddrPubkeyRelationKey(address)), &pubkey) if err != nil { - return nil, fmt.Errorf("address %v not found", address) + return nil, fmt.Errorf("address %s not found", sdk.ConsAddress(address)) } return pubkey, nil } diff --git a/x/slashing/keeper_test.go b/x/slashing/keeper_test.go index 98a204342..523cc6485 100644 --- a/x/slashing/keeper_test.go +++ b/x/slashing/keeper_test.go @@ -39,7 +39,7 @@ func TestHandleDoubleSign(t *testing.T) { staking.EndBlocker(ctx, sk) require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.NewCoins(sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))), ) require.Equal(t, amt, sk.Validator(ctx, operatorAddr).GetBondedTokens()) @@ -100,7 +100,7 @@ func TestPastMaxEvidenceAge(t *testing.T) { staking.EndBlocker(ctx, sk) require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.NewCoins(sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))), ) require.Equal(t, amt, sk.Validator(ctx, operatorAddr).GetBondedTokens()) @@ -138,7 +138,7 @@ func TestHandleAbsentValidator(t *testing.T) { require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(addr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.NewCoins(sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))), ) require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens()) @@ -174,8 +174,8 @@ func TestHandleAbsentValidator(t *testing.T) { // validator should be bonded still validator, _ := sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) require.Equal(t, sdk.Bonded, validator.GetStatus()) - pool := sk.GetPool(ctx) - require.True(sdk.IntEq(t, amt, pool.BondedTokens)) + bondPool := sk.GetBondedPool(ctx) + require.True(sdk.IntEq(t, amt, bondPool.GetCoins().AmountOf(sk.BondDenom(ctx)))) // 501st block missed ctx = ctx.WithBlockHeight(height) @@ -231,8 +231,8 @@ func TestHandleAbsentValidator(t *testing.T) { require.Equal(t, sdk.Bonded, validator.GetStatus()) // validator should have been slashed - pool = sk.GetPool(ctx) - require.Equal(t, amt.Int64()-slashAmt, pool.BondedTokens.Int64()) + bondPool = sk.GetBondedPool(ctx) + require.Equal(t, amt.Int64()-slashAmt, bondPool.GetCoins().AmountOf(sk.BondDenom(ctx)).Int64()) // Validator start height should not have been changed info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address())) @@ -292,7 +292,7 @@ func TestHandleNewValidator(t *testing.T) { require.Equal( t, ck.GetCoins(ctx, sdk.AccAddress(addr)), - sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))}, + sdk.NewCoins(sdk.NewCoin(sk.GetParams(ctx).BondDenom, initTokens.Sub(amt))), ) require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens()) @@ -311,9 +311,9 @@ func TestHandleNewValidator(t *testing.T) { // validator should be bonded still, should not have been jailed or slashed validator, _ := sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) require.Equal(t, sdk.Bonded, validator.GetStatus()) - pool := sk.GetPool(ctx) + bondPool := sk.GetBondedPool(ctx) expTokens := sdk.TokensFromConsensusPower(100) - require.Equal(t, expTokens, pool.BondedTokens) + require.Equal(t, expTokens.Int64(), bondPool.GetCoins().AmountOf(sk.BondDenom(ctx)).Int64()) } // Test a jailed validator being "down" twice diff --git a/x/slashing/test_common.go b/x/slashing/test_common.go index b9f22bcb3..310f28f3e 100644 --- a/x/slashing/test_common.go +++ b/x/slashing/test_common.go @@ -21,6 +21,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/params" "github.com/cosmos/cosmos-sdk/x/staking" + "github.com/cosmos/cosmos-sdk/x/supply" ) // TODO remove dependencies on staking (should only refer to validator set type from sdk) @@ -36,13 +37,15 @@ var ( sdk.ValAddress(pks[1].Address()), sdk.ValAddress(pks[2].Address()), } - initCoins = sdk.TokensFromConsensusPower(200) + initTokens = sdk.TokensFromConsensusPower(200) + initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) ) func createTestCodec() *codec.Codec { cdc := codec.New() sdk.RegisterCodec(cdc) auth.RegisterCodec(cdc) + supply.RegisterCodec(cdc) bank.RegisterCodec(cdc) staking.RegisterCodec(cdc) codec.RegisterCrypto(cdc) @@ -54,6 +57,7 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s keyStaking := sdk.NewKVStoreKey(staking.StoreKey) tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey) keySlashing := sdk.NewKVStoreKey(StoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) keyParams := sdk.NewKVStoreKey(params.StoreKey) tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey) db := dbm.NewMemDB() @@ -61,6 +65,7 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyStaking, sdk.StoreTypeTransient, nil) ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db) + ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keySlashing, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) @@ -71,18 +76,29 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s paramsKeeper := params.NewKeeper(cdc, keyParams, tkeyParams, params.DefaultCodespace) accountKeeper := auth.NewAccountKeeper(cdc, keyAcc, paramsKeeper.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount) - ck := bank.NewBaseKeeper(accountKeeper, paramsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) - sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, ck, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) + bk := bank.NewBaseKeeper(accountKeeper, paramsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) + supplyKeeper := supply.NewKeeper(cdc, keySupply, accountKeeper, bk, supply.DefaultCodespace, + []string{auth.FeeCollectorName}, []string{}, []string{staking.NotBondedPoolName, staking.BondedPoolName}) + + totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens.MulRaw(int64(len(addrs))))) + supplyKeeper.SetSupply(ctx, supply.NewSupply(totalSupply)) + + sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, supplyKeeper, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace) genesis := staking.DefaultGenesisState() - genesis.Pool.NotBondedTokens = initCoins.MulRaw(int64(len(addrs))) + // set module accounts + feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName, supply.Basic) + notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner) - _ = staking.InitGenesis(ctx, sk, accountKeeper, genesis) + supplyKeeper.SetModuleAccount(ctx, feeCollectorAcc) + supplyKeeper.SetModuleAccount(ctx, bondPool) + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + + _ = staking.InitGenesis(ctx, sk, accountKeeper, supplyKeeper, genesis) for _, addr := range addrs { - _, err = ck.AddCoins(ctx, sdk.AccAddress(addr), sdk.Coins{ - {sk.GetParams(ctx).BondDenom, initCoins}, - }) + _, err = bk.AddCoins(ctx, sdk.AccAddress(addr), initCoins) } require.Nil(t, err) paramstore := paramsKeeper.Subspace(DefaultParamspace) @@ -93,7 +109,7 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s InitGenesis(ctx, keeper, sk, GenesisState{defaults, nil, nil}) }) - return ctx, ck, sk, paramstore, keeper + return ctx, bk, sk, paramstore, keeper } func newPubKey(pk string) (res crypto.PubKey) { diff --git a/x/staking/alias.go b/x/staking/alias.go index c3c1c87d2..84515957a 100644 --- a/x/staking/alias.go +++ b/x/staking/alias.go @@ -31,6 +31,8 @@ const ( DefaultUnbondingTime = types.DefaultUnbondingTime DefaultMaxValidators = types.DefaultMaxValidators DefaultMaxEntries = types.DefaultMaxEntries + NotBondedPoolName = types.NotBondedPoolName + BondedPoolName = types.BondedPoolName QueryValidators = types.QueryValidators QueryValidator = types.QueryValidator QueryDelegatorDelegations = types.QueryDelegatorDelegations @@ -56,7 +58,7 @@ var ( // functions aliases RegisterInvariants = keeper.RegisterInvariants AllInvariants = keeper.AllInvariants - SupplyInvariants = keeper.SupplyInvariants + ModuleAccountInvariants = keeper.ModuleAccountInvariants NonNegativePowerInvariant = keeper.NonNegativePowerInvariant PositiveDelegationInvariant = keeper.PositiveDelegationInvariant DelegatorSharesInvariant = keeper.DelegatorSharesInvariant @@ -166,9 +168,7 @@ var ( DefaultParams = types.DefaultParams MustUnmarshalParams = types.MustUnmarshalParams UnmarshalParams = types.UnmarshalParams - InitialPool = types.InitialPool - MustUnmarshalPool = types.MustUnmarshalPool - UnmarshalPool = types.UnmarshalPool + NewPool = types.NewPool NewQueryDelegatorParams = types.NewQueryDelegatorParams NewQueryValidatorParams = types.NewQueryValidatorParams NewQueryBondsParams = types.NewQueryBondsParams @@ -223,7 +223,6 @@ type ( RedelegationEntryResponse = types.RedelegationEntryResponse RedelegationResponses = types.RedelegationResponses CodeType = types.CodeType - AccountKeeper = types.AccountKeeper GenesisState = types.GenesisState LastValidatorPower = types.LastValidatorPower MultiStakingHooks = types.MultiStakingHooks diff --git a/x/staking/app_test.go b/x/staking/app_test.go index 9dd0ed47e..2cfc14efd 100644 --- a/x/staking/app_test.go +++ b/x/staking/app_test.go @@ -11,6 +11,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/mock" "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/cosmos/cosmos-sdk/x/supply" ) // getMockApp returns an initialized mock application for this module. @@ -18,18 +19,22 @@ func getMockApp(t *testing.T) (*mock.App, Keeper) { mApp := mock.NewApp() RegisterCodec(mApp.Cdc) + supply.RegisterCodec(mApp.Cdc) keyStaking := sdk.NewKVStoreKey(StoreKey) tkeyStaking := sdk.NewTransientStoreKey(TStoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) bankKeeper := bank.NewBaseKeeper(mApp.AccountKeeper, mApp.ParamsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) - keeper := NewKeeper(mApp.Cdc, keyStaking, tkeyStaking, bankKeeper, mApp.ParamsKeeper.Subspace(DefaultParamspace), DefaultCodespace) + supplyKeeper := supply.NewKeeper(mApp.Cdc, keySupply, mApp.AccountKeeper, bankKeeper, supply.DefaultCodespace, + []string{auth.FeeCollectorName}, []string{}, []string{types.NotBondedPoolName, types.BondedPoolName}) + keeper := NewKeeper(mApp.Cdc, keyStaking, tkeyStaking, supplyKeeper, mApp.ParamsKeeper.Subspace(DefaultParamspace), DefaultCodespace) mApp.Router().AddRoute(RouterKey, NewHandler(keeper)) mApp.SetEndBlocker(getEndBlocker(keeper)) - mApp.SetInitChainer(getInitChainer(mApp, keeper, mApp.AccountKeeper)) + mApp.SetInitChainer(getInitChainer(mApp, keeper, mApp.AccountKeeper, supplyKeeper)) - require.NoError(t, mApp.CompleteSetup(keyStaking, tkeyStaking)) + require.NoError(t, mApp.CompleteSetup(keyStaking, tkeyStaking, keySupply)) return mApp, keeper } @@ -46,15 +51,21 @@ func getEndBlocker(keeper Keeper) sdk.EndBlocker { // getInitChainer initializes the chainer of the mock app and sets the genesis // state. It returns an empty ResponseInitChain. -func getInitChainer(mapp *mock.App, keeper Keeper, accountKeeper types.AccountKeeper) sdk.InitChainer { +func getInitChainer(mapp *mock.App, keeper Keeper, accountKeeper types.AccountKeeper, supplyKeeper types.SupplyKeeper) sdk.InitChainer { return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain { mapp.InitChainer(ctx, req) - stakingGenesis := DefaultGenesisState() - tokens := sdk.TokensFromConsensusPower(100000) - stakingGenesis.Pool.NotBondedTokens = tokens + // set module accounts + feeCollector := supply.NewEmptyModuleAccount(auth.FeeCollectorName, supply.Basic) + notBondedPool := supply.NewEmptyModuleAccount(types.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(types.BondedPoolName, supply.Burner) - validators := InitGenesis(ctx, keeper, accountKeeper, stakingGenesis) + supplyKeeper.SetModuleAccount(ctx, feeCollector) + supplyKeeper.SetModuleAccount(ctx, bondPool) + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + + stakingGenesis := DefaultGenesisState() + validators := InitGenesis(ctx, keeper, accountKeeper, supplyKeeper, stakingGenesis) return abci.ResponseInitChain{ Validators: validators, } diff --git a/x/staking/client/cli/query.go b/x/staking/client/cli/query.go index e0fb7417c..9e0352f93 100644 --- a/x/staking/client/cli/query.go +++ b/x/staking/client/cli/query.go @@ -545,17 +545,22 @@ $ %s query staking pool RunE: func(cmd *cobra.Command, args []string) error { cliCtx := context.NewCLIContext().WithCodec(cdc) - res, _, err := cliCtx.QueryStore(types.PoolKey, storeName) + bz, _, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/pool", storeName), nil) if err != nil { return err } - return cliCtx.PrintOutput(types.MustUnmarshalPool(cdc, res)) + var pool types.Pool + if err := cdc.UnmarshalJSON(bz, &pool); err != nil { + return err + } + + return cliCtx.PrintOutput(pool) }, } } -// GetCmdQueryPool implements the params query command. +// GetCmdQueryParams implements the params query command. func GetCmdQueryParams(storeName string, cdc *codec.Codec) *cobra.Command { return &cobra.Command{ Use: "params", diff --git a/x/staking/genesis.go b/x/staking/genesis.go index e96c1d655..91d3a41f6 100644 --- a/x/staking/genesis.go +++ b/x/staking/genesis.go @@ -7,7 +7,6 @@ import ( tmtypes "github.com/tendermint/tendermint/types" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/staking/exported" "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -17,7 +16,11 @@ import ( // setting the indexes. In addition, it also sets any delegations found in // data. Finally, it updates the bonded validators. // Returns final validator set after applying all declaration and delegations -func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeeper, data types.GenesisState) (res []abci.ValidatorUpdate) { +func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeeper, + supplyKeeper types.SupplyKeeper, data types.GenesisState) (res []abci.ValidatorUpdate) { + + bondedTokens := sdk.ZeroInt() + notBondedTokens := sdk.ZeroInt() // We need to pretend to be "n blocks before genesis", where "n" is the // validator update delay, so that e.g. slashing periods are correctly @@ -26,18 +29,6 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeep // genesis.json are in block 0. ctx = ctx.WithBlockHeight(1 - sdk.ValidatorUpdateDelay) - // manually set the total supply for staking based on accounts if not provided - if data.Pool.NotBondedTokens.IsZero() { - accountKeeper.IterateAccounts(ctx, - func(acc auth.Account) (stop bool) { - data.Pool.NotBondedTokens = data.Pool.NotBondedTokens. - Add(acc.GetCoins().AmountOf(data.Params.BondDenom)) - return false - }, - ) - } - - keeper.SetPool(ctx, data.Pool) // TODO remove pool from genesis data and always calculate? keeper.SetParams(ctx, data.Params) keeper.SetLastTotalPower(ctx, data.LastTotalPower) @@ -53,10 +44,19 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeep keeper.AfterValidatorCreated(ctx, validator.OperatorAddress) } - // Set timeslice if necessary + // update timeslice if necessary if validator.IsUnbonding() { keeper.InsertValidatorQueue(ctx, validator) } + + switch validator.GetStatus() { + case sdk.Bonded: + bondedTokens = bondedTokens.Add(validator.GetTokens()) + case sdk.Unbonding, sdk.Unbonded: + notBondedTokens = notBondedTokens.Add(validator.GetTokens()) + default: + panic("invalid validator status") + } } for _, delegation := range data.Delegations { @@ -65,6 +65,7 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeep keeper.BeforeDelegationCreated(ctx, delegation.DelegatorAddress, delegation.ValidatorAddress) } keeper.SetDelegation(ctx, delegation) + // Call the after-modification hook if not exported if !data.Exported { keeper.AfterDelegationModified(ctx, delegation.DelegatorAddress, delegation.ValidatorAddress) @@ -75,6 +76,7 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeep keeper.SetUnbondingDelegation(ctx, ubd) for _, entry := range ubd.Entries { keeper.InsertUBDQueue(ctx, ubd, entry.CompletionTime) + notBondedTokens = notBondedTokens.Add(entry.Balance) } } @@ -85,13 +87,43 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeep } } + bondedCoins := sdk.NewCoins(sdk.NewCoin(data.Params.BondDenom, bondedTokens)) + notBondedCoins := sdk.NewCoins(sdk.NewCoin(data.Params.BondDenom, notBondedTokens)) + + // check if the unbonded and bonded pools accounts exists + bondedPool := keeper.GetBondedPool(ctx) + if bondedPool == nil { + panic(fmt.Sprintf("%s module account has not been set", types.BondedPoolName)) + } + + // TODO remove with genesis 2-phases refactor https://github.com/cosmos/cosmos-sdk/issues/2862 + // add coins if not provided on genesis + if bondedPool.GetCoins().IsZero() { + if err := bondedPool.SetCoins(bondedCoins); err != nil { + panic(err) + } + supplyKeeper.SetModuleAccount(ctx, bondedPool) + } + + notBondedPool := keeper.GetNotBondedPool(ctx) + if notBondedPool == nil { + panic(fmt.Sprintf("%s module account has not been set", types.NotBondedPoolName)) + } + + if notBondedPool.GetCoins().IsZero() { + if err := notBondedPool.SetCoins(notBondedCoins); err != nil { + panic(err) + } + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + } + // don't need to run Tendermint updates if we exported if data.Exported { for _, lv := range data.LastValidatorPowers { keeper.SetLastValidatorPower(ctx, lv.Address, lv.Power) validator, found := keeper.GetValidator(ctx, lv.Address) if !found { - panic("expected validator, not found") + panic(fmt.Sprintf("validator %s not found", lv.Address)) } update := validator.ABCIValidatorUpdate() update.Power = lv.Power // keep the next-val-set offset, use the last power for the first block @@ -108,7 +140,6 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, accountKeeper types.AccountKeep // GenesisState will contain the pool, params, validators, and bonds found in // the keeper. func ExportGenesis(ctx sdk.Context, keeper Keeper) types.GenesisState { - pool := keeper.GetPool(ctx) params := keeper.GetParams(ctx) lastTotalPower := keeper.GetLastTotalPower(ctx) validators := keeper.GetAllValidators(ctx) @@ -130,7 +161,6 @@ func ExportGenesis(ctx sdk.Context, keeper Keeper) types.GenesisState { }) return types.GenesisState{ - Pool: pool, Params: params, LastTotalPower: lastTotalPower, LastValidatorPowers: lastValidatorPowers, diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go index 52cadae2b..5e856664a 100644 --- a/x/staking/genesis_test.go +++ b/x/staking/genesis_test.go @@ -17,10 +17,8 @@ import ( ) func TestInitGenesis(t *testing.T) { - ctx, accKeeper, keeper := keep.CreateTestInput(t, false, 1000) + ctx, accKeeper, keeper, supplyKeeper := keep.CreateTestInput(t, false, 1000) - pool := keeper.GetPool(ctx) - pool.BondedTokens = sdk.TokensFromConsensusPower(2) valTokens := sdk.TokensFromConsensusPower(1) params := keeper.GetParams(ctx) @@ -41,11 +39,10 @@ func TestInitGenesis(t *testing.T) { validators[1].Tokens = valTokens validators[1].DelegatorShares = valTokens.ToDec() - genesisState := types.NewGenesisState(pool, params, validators, delegations) - vals := InitGenesis(ctx, keeper, accKeeper, genesisState) + genesisState := types.NewGenesisState(params, validators, delegations) + vals := InitGenesis(ctx, keeper, accKeeper, supplyKeeper, genesisState) actualGenesis := ExportGenesis(ctx, keeper) - require.Equal(t, genesisState.Pool, actualGenesis.Pool) require.Equal(t, genesisState.Params, actualGenesis.Params) require.Equal(t, genesisState.Delegations, actualGenesis.Delegations) require.EqualValues(t, keeper.GetAllValidators(ctx), actualGenesis.Validators) @@ -71,12 +68,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) { size := 200 require.True(t, size > 100) - ctx, accKeeper, keeper := keep.CreateTestInput(t, false, 1000) - - // Assigning 2 to the first 100 vals, 1 to the rest - pool := keeper.GetPool(ctx) - bondedTokens := sdk.TokensFromConsensusPower(int64(200 + (size - 100))) - pool.BondedTokens = bondedTokens + ctx, accKeeper, keeper, supplyKeeper := keep.CreateTestInput(t, false, 1000) params := keeper.GetParams(ctx) delegations := []Delegation{} @@ -96,8 +88,8 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) { validators[i].DelegatorShares = tokens.ToDec() } - genesisState := types.NewGenesisState(pool, params, validators, delegations) - vals := InitGenesis(ctx, keeper, accKeeper, genesisState) + genesisState := types.NewGenesisState(params, validators, delegations) + vals := InitGenesis(ctx, keeper, accKeeper, supplyKeeper, genesisState) abcivals := make([]abci.ValidatorUpdate, 100) for i, val := range validators[:100] { diff --git a/x/staking/handler.go b/x/staking/handler.go index 3bedb34e6..bafa1d325 100644 --- a/x/staking/handler.go +++ b/x/staking/handler.go @@ -146,7 +146,8 @@ func handleMsgCreateValidator(ctx sdk.Context, msg types.MsgCreateValidator, k k // move coins from the msg.Address account to a (self-delegation) delegator account // the validator account and global shares are updated within here - _, err = k.Delegate(ctx, msg.DelegatorAddress, msg.Value.Amount, validator, true) + // NOTE source will always be from a wallet which are unbonded + _, err = k.Delegate(ctx, msg.DelegatorAddress, msg.Value.Amount, sdk.Unbonded, validator, true) if err != nil { return err.Result() } @@ -232,7 +233,8 @@ func handleMsgDelegate(ctx sdk.Context, msg types.MsgDelegate, k keeper.Keeper) return ErrBadDenom(k.Codespace()).Result() } - _, err := k.Delegate(ctx, msg.DelegatorAddress, msg.Amount.Amount, validator, true) + // NOTE: source funds are always unbonded + _, err := k.Delegate(ctx, msg.DelegatorAddress, msg.Amount.Amount, sdk.Unbonded, validator, true) if err != nil { return err.Result() } diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go index 6aea3541c..f6329824b 100644 --- a/x/staking/handler_test.go +++ b/x/staking/handler_test.go @@ -34,7 +34,7 @@ func TestValidatorByPowerIndex(t *testing.T) { initPower := int64(1000000) initBond := sdk.TokensFromConsensusPower(initPower) - ctx, _, keeper := keep.CreateTestInput(t, false, initPower) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, initPower) _ = setInstantUnbondPeriod(keeper, ctx) // create validator @@ -114,7 +114,7 @@ func TestValidatorByPowerIndex(t *testing.T) { } func TestDuplicatesMsgCreateValidator(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) addr1, addr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]) pk1, pk2 := keep.PKs[0], keep.PKs[1] @@ -166,7 +166,7 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) { } func TestInvalidPubKeyTypeMsgCreateValidator(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) addr := sdk.ValAddress(keep.Addrs[0]) invalidPk := secp256k1.GenPrivKey().PubKey() @@ -185,7 +185,7 @@ func TestInvalidPubKeyTypeMsgCreateValidator(t *testing.T) { } func TestLegacyValidatorDelegations(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, int64(1000)) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, int64(1000)) setInstantUnbondPeriod(keeper, ctx) bondAmount := sdk.TokensFromConsensusPower(10) @@ -279,7 +279,7 @@ func TestLegacyValidatorDelegations(t *testing.T) { func TestIncrementsMsgDelegate(t *testing.T) { initPower := int64(1000) initBond := sdk.TokensFromConsensusPower(initPower) - ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower) + ctx, accMapper, keeper, _ := keep.CreateTestInput(t, false, initPower) params := keeper.GetParams(ctx) bondAmount := sdk.TokensFromConsensusPower(10) @@ -306,8 +306,8 @@ func TestIncrementsMsgDelegate(t *testing.T) { require.True(t, found) require.Equal(t, bondAmount, bond.Shares.RoundInt()) - pool := keeper.GetPool(ctx) - require.Equal(t, bondAmount, pool.BondedTokens) + bondedTokens := keeper.TotalBondedTokens(ctx) + require.Equal(t, bondAmount.Int64(), bondedTokens.Int64()) // just send the same msgbond multiple times msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, bondAmount) @@ -349,7 +349,7 @@ func TestEditValidatorDecreaseMinSelfDelegation(t *testing.T) { initPower := int64(100) initBond := sdk.TokensFromConsensusPower(100) - ctx, _, keeper := keep.CreateTestInput(t, false, initPower) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, initPower) _ = setInstantUnbondPeriod(keeper, ctx) // create validator @@ -381,7 +381,7 @@ func TestEditValidatorIncreaseMinSelfDelegationBeyondCurrentBond(t *testing.T) { initPower := int64(100) initBond := sdk.TokensFromConsensusPower(100) - ctx, _, keeper := keep.CreateTestInput(t, false, initPower) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, initPower) _ = setInstantUnbondPeriod(keeper, ctx) // create validator @@ -411,7 +411,7 @@ func TestEditValidatorIncreaseMinSelfDelegationBeyondCurrentBond(t *testing.T) { func TestIncrementsMsgUnbond(t *testing.T) { initPower := int64(1000) initBond := sdk.TokensFromConsensusPower(initPower) - ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower) + ctx, accMapper, keeper, _ := keep.CreateTestInput(t, false, initPower) params := setInstantUnbondPeriod(keeper, ctx) denom := params.BondDenom @@ -469,13 +469,13 @@ func TestIncrementsMsgUnbond(t *testing.T) { gotDelegatorShares := validator.DelegatorShares.RoundInt() gotDelegatorAcc := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(params.BondDenom) - require.Equal(t, expBond, gotBond, + require.Equal(t, expBond.Int64(), gotBond.Int64(), "i: %v\nexpBond: %v\ngotBond: %v\nvalidator: %v\nbond: %v\n", i, expBond, gotBond, validator, bond) - require.Equal(t, expDelegatorShares, gotDelegatorShares, + require.Equal(t, expDelegatorShares.Int64(), gotDelegatorShares.Int64(), "i: %v\nexpDelegatorShares: %v\ngotDelegatorShares: %v\nvalidator: %v\nbond: %v\n", i, expDelegatorShares, gotDelegatorShares, validator, bond) - require.Equal(t, expDelegatorAcc, gotDelegatorAcc, + require.Equal(t, expDelegatorAcc.Int64(), gotDelegatorAcc.Int64(), "i: %v\nexpDelegatorAcc: %v\ngotDelegatorAcc: %v\nvalidator: %v\nbond: %v\n", i, expDelegatorAcc, gotDelegatorAcc, validator, bond) } @@ -509,7 +509,7 @@ func TestIncrementsMsgUnbond(t *testing.T) { func TestMultipleMsgCreateValidator(t *testing.T) { initPower := int64(1000) initTokens := sdk.TokensFromConsensusPower(initPower) - ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower) + ctx, accMapper, keeper, _ := keep.CreateTestInput(t, false, initPower) params := setInstantUnbondPeriod(keeper, ctx) validatorAddrs := []sdk.ValAddress{ @@ -576,7 +576,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) { } func TestMultipleMsgDelegate(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr, delegatorAddrs := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1:] _ = setInstantUnbondPeriod(keeper, ctx) @@ -618,7 +618,7 @@ func TestMultipleMsgDelegate(t *testing.T) { } func TestJailValidator(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1] _ = setInstantUnbondPeriod(keeper, ctx) @@ -664,7 +664,7 @@ func TestJailValidator(t *testing.T) { } func TestValidatorQueue(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1] // set the unbonding time @@ -722,7 +722,7 @@ func TestValidatorQueue(t *testing.T) { } func TestUnbondingPeriod(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr := sdk.ValAddress(keep.Addrs[0]) // set the unbonding time @@ -768,7 +768,7 @@ func TestUnbondingPeriod(t *testing.T) { } func TestUnbondingFromUnbondingValidator(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1] // create the validator @@ -809,7 +809,7 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) { } func TestRedelegationPeriod(t *testing.T) { - ctx, AccMapper, keeper := keep.CreateTestInput(t, false, 1000) + ctx, AccMapper, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr, validatorAddr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]) denom := keeper.GetParams(ctx).BondDenom @@ -868,7 +868,7 @@ func TestRedelegationPeriod(t *testing.T) { } func TestTransitiveRedelegation(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr := sdk.ValAddress(keep.Addrs[0]) validatorAddr2 := sdk.ValAddress(keep.Addrs[1]) validatorAddr3 := sdk.ValAddress(keep.Addrs[2]) @@ -911,7 +911,7 @@ func TestTransitiveRedelegation(t *testing.T) { } func TestMultipleRedelegationAtSameTime(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) valAddr := sdk.ValAddress(keep.Addrs[0]) valAddr2 := sdk.ValAddress(keep.Addrs[1]) @@ -963,7 +963,7 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) { } func TestMultipleRedelegationAtUniqueTimes(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) valAddr := sdk.ValAddress(keep.Addrs[0]) valAddr2 := sdk.ValAddress(keep.Addrs[1]) @@ -1017,7 +1017,7 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) { } func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) valAddr := sdk.ValAddress(keep.Addrs[0]) // set the unbonding time @@ -1064,7 +1064,7 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) { } func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) valAddr := sdk.ValAddress(keep.Addrs[0]) // set the unbonding time @@ -1118,7 +1118,7 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) { } func TestUnbondingWhenExcessValidators(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) validatorAddr1 := sdk.ValAddress(keep.Addrs[0]) validatorAddr2 := sdk.ValAddress(keep.Addrs[1]) validatorAddr3 := sdk.ValAddress(keep.Addrs[2]) @@ -1174,7 +1174,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) { } func TestBondUnbondRedelegateSlashTwice(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) valA, valB, del := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), keep.Addrs[2] consAddr0 := sdk.ConsAddress(keep.PKs[0].Address()) @@ -1283,7 +1283,7 @@ func TestInvalidMsg(t *testing.T) { } func TestInvalidCoinDenom(t *testing.T) { - ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := keep.CreateTestInput(t, false, 1000) valA, valB, delAddr := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), keep.Addrs[2] valTokens := sdk.TokensFromConsensusPower(100) diff --git a/x/staking/keeper/alias_functions.go b/x/staking/keeper/alias_functions.go index be9cf2078..ca5696b6c 100644 --- a/x/staking/keeper/alias_functions.go +++ b/x/staking/keeper/alias_functions.go @@ -88,31 +88,6 @@ func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) expor return val } -// total staking tokens supply which is bonded -func (k Keeper) TotalBondedTokens(ctx sdk.Context) sdk.Int { - pool := k.GetPool(ctx) - return pool.BondedTokens -} - -// total staking tokens supply bonded and unbonded -func (k Keeper) TotalTokens(ctx sdk.Context) sdk.Int { - pool := k.GetPool(ctx) - return pool.TokenSupply() -} - -// the fraction of the staking tokens which are currently bonded -func (k Keeper) BondedRatio(ctx sdk.Context) sdk.Dec { - pool := k.GetPool(ctx) - return pool.BondedRatio() -} - -// when minting new tokens -func (k Keeper) InflateSupply(ctx sdk.Context, newTokens sdk.Int) { - pool := k.GetPool(ctx) - pool.NotBondedTokens = pool.NotBondedTokens.Add(newTokens) - k.SetPool(ctx, pool) -} - //_______________________________________________________________________ // Delegation Set diff --git a/x/staking/keeper/delegation.go b/x/staking/keeper/delegation.go index 8dd85e3ac..2c0d8e52d 100644 --- a/x/staking/keeper/delegation.go +++ b/x/staking/keeper/delegation.go @@ -25,16 +25,26 @@ func (k Keeper) GetDelegation(ctx sdk.Context, return delegation, true } -// return all delegations used during genesis dump -func (k Keeper) GetAllDelegations(ctx sdk.Context) (delegations []types.Delegation) { +// IterateAllDelegations iterate through all of the delegations +func (k Keeper) IterateAllDelegations(ctx sdk.Context, cb func(delegation types.Delegation) (stop bool)) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, types.DelegationKey) defer iterator.Close() for ; iterator.Valid(); iterator.Next() { delegation := types.MustUnmarshalDelegation(k.cdc, iterator.Value()) - delegations = append(delegations, delegation) + if cb(delegation) { + break + } } +} + +// GetAllDelegations returns all delegations used during genesis dump +func (k Keeper) GetAllDelegations(ctx sdk.Context) (delegations []types.Delegation) { + k.IterateAllDelegations(ctx, func(delegation types.Delegation) bool { + delegations = append(delegations, delegation) + return false + }) return delegations } @@ -292,7 +302,7 @@ func (k Keeper) GetRedelegation(ctx sdk.Context, } // return all redelegations from a particular validator -func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.ValAddress) (reds []types.Redelegation) { +func (k Keeper) GetRedelegationsFromSrcValidator(ctx sdk.Context, valAddr sdk.ValAddress) (reds []types.Redelegation) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, types.GetREDsFromValSrcIndexKey(valAddr)) defer iterator.Close() @@ -445,7 +455,8 @@ func (k Keeper) DequeueAllMatureRedelegationQueue(ctx sdk.Context, currTime time } // Perform a delegation, set/update everything necessary within the store. -func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int, +// tokenSrc indicates the bond status of the incoming funds. +func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int, tokenSrc sdk.BondStatus, validator types.Validator, subtractAccount bool) (newShares sdk.Dec, err sdk.Error) { // In some situations, the exchange rate becomes invalid, e.g. if @@ -468,11 +479,46 @@ func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.In k.BeforeDelegationCreated(ctx, delAddr, validator.OperatorAddress) } + // if subtractAccount is true then we are + // performing a delegation and not a redelegation, thus the source tokens are + // all non bonded if subtractAccount { - err := k.bankKeeper.DelegateCoins(ctx, delegation.DelegatorAddress, sdk.Coins{sdk.NewCoin(k.GetParams(ctx).BondDenom, bondAmt)}) + if tokenSrc == sdk.Bonded { + panic("delegation token source cannot be bonded") + } + + var sendName string + switch { + case validator.IsBonded(): + sendName = types.BondedPoolName + case validator.IsUnbonding(), validator.IsUnbonded(): + sendName = types.NotBondedPoolName + default: + panic("invalid validator status") + } + + coins := sdk.NewCoins(sdk.NewCoin(k.BondDenom(ctx), bondAmt)) + err := k.supplyKeeper.DelegateCoinsFromAccountToModule(ctx, delegation.DelegatorAddress, sendName, coins) if err != nil { return sdk.Dec{}, err } + } else { + + // potentially transfer tokens between pools, if + switch { + case tokenSrc == sdk.Bonded && validator.IsBonded(): + // do nothing + case (tokenSrc == sdk.Unbonded || tokenSrc == sdk.Unbonding) && !validator.IsBonded(): + // do nothing + case (tokenSrc == sdk.Unbonded || tokenSrc == sdk.Unbonding) && validator.IsBonded(): + // transfer pools + k.notBondedTokensToBonded(ctx, bondAmt) + case tokenSrc == sdk.Bonded && !validator.IsBonded(): + // transfer pools + k.bondedTokensToNotBonded(ctx, bondAmt) + default: + panic("unknown token source bond status") + } } validator, newShares = k.AddValidatorTokensAndShares(ctx, validator, bondAmt) @@ -514,7 +560,7 @@ func (k Keeper) unbond(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValA // subtract shares from delegation delegation.Shares = delegation.Shares.Sub(shares) - isValidatorOperator := bytes.Equal(delegation.DelegatorAddress, validator.OperatorAddress) + isValidatorOperator := delegation.DelegatorAddress.Equals(validator.OperatorAddress) // if the delegation is the operator of the validator and undelegating will decrease the validator's self delegation below their minimum // trigger a jail validator @@ -535,6 +581,7 @@ func (k Keeper) unbond(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValA } // remove the shares and coins from the validator + // NOTE that the amount is later (in keeper.Delegation) moved between staking module pools validator, amount = k.RemoveValidatorTokensAndShares(ctx, validator, shares) if validator.DelegatorShares.IsZero() && validator.IsUnbonded() { @@ -583,6 +630,11 @@ func (k Keeper) Undelegate( ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec, ) (time.Time, sdk.Error) { + validator, found := k.GetValidator(ctx, valAddr) + if !found { + return time.Time{}, types.ErrNoDelegatorForAddress(k.Codespace()) + } + if k.HasMaxUnbondingDelegationEntries(ctx, delAddr, valAddr) { return time.Time{}, types.ErrMaxUnbondingDelegationEntries(k.Codespace()) } @@ -592,6 +644,11 @@ func (k Keeper) Undelegate( return time.Time{}, err } + // transfer the validator tokens to the not bonded pool + if validator.IsBonded() { + k.bondedTokensToNotBonded(ctx, returnAmount) + } + completionTime := ctx.BlockHeader().Time.Add(k.UnbondingTime(ctx)) ubd := k.SetUnbondingDelegationEntry(ctx, delAddr, valAddr, ctx.BlockHeight(), completionTime, returnAmount) k.InsertUBDQueue(ctx, ubd, completionTime) @@ -620,7 +677,8 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress, // track undelegation only when remaining or truncated shares are non-zero if !entry.Balance.IsZero() { - err := k.bankKeeper.UndelegateCoins(ctx, ubd.DelegatorAddress, sdk.Coins{sdk.NewCoin(k.GetParams(ctx).BondDenom, entry.Balance)}) + amt := sdk.NewCoins(sdk.NewCoin(k.GetParams(ctx).BondDenom, entry.Balance)) + err := k.supplyKeeper.UndelegateCoinsFromModuleToAccount(ctx, types.NotBondedPoolName, ubd.DelegatorAddress, amt) if err != nil { return err } @@ -647,6 +705,16 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress, return time.Time{}, types.ErrSelfRedelegation(k.Codespace()) } + dstValidator, found := k.GetValidator(ctx, valDstAddr) + if !found { + return time.Time{}, types.ErrBadRedelegationDst(k.Codespace()) + } + + srcValidator, found := k.GetValidator(ctx, valSrcAddr) + if !found { + return time.Time{}, types.ErrBadRedelegationDst(k.Codespace()) + } + // check if this is a transitive redelegation if k.HasReceivingRedelegation(ctx, delAddr, valSrcAddr) { return time.Time{}, types.ErrTransitiveRedelegation(k.Codespace()) @@ -664,12 +732,8 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress, if returnAmount.IsZero() { return time.Time{}, types.ErrVerySmallRedelegation(k.Codespace()) } - dstValidator, found := k.GetValidator(ctx, valDstAddr) - if !found { - return time.Time{}, types.ErrBadRedelegationDst(k.Codespace()) - } - sharesCreated, err := k.Delegate(ctx, delAddr, returnAmount, dstValidator, false) + sharesCreated, err := k.Delegate(ctx, delAddr, returnAmount, srcValidator.GetStatus(), dstValidator, false) if err != nil { return time.Time{}, err } diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go index 1a3278bdb..7d9403b50 100644 --- a/x/staking/keeper/delegation_test.go +++ b/x/staking/keeper/delegation_test.go @@ -13,18 +13,16 @@ import ( // tests GetDelegation, GetDelegatorDelegations, SetDelegation, RemoveDelegation, GetDelegatorDelegations func TestDelegation(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 10) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 10) //construct the validators amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} var validators [3]types.Validator for i, amt := range amts { validators[i] = types.NewValidator(addrVals[i], PKs[i], types.Description{}) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt) + validators[i], _ = validators[i].AddTokensFromDel(amt) } - keeper.SetPool(ctx, pool) validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], true) validators[2] = TestingUpdateValidator(keeper, ctx, validators[2], true) @@ -130,7 +128,7 @@ func TestDelegation(t *testing.T) { // tests Get/Set/Remove UnbondingDelegation func TestUnbondingDelegation(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 0, time.Unix(0, 0), sdk.NewInt(5)) @@ -169,21 +167,23 @@ func TestUnbondingDelegation(t *testing.T) { } func TestUnbondDelegation(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) + startTokens := sdk.TokensFromConsensusPower(10) - pool.NotBondedTokens = startTokens - //create a validator and a delegator to that validator + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens))) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + + // create a validator and a delegator to that validator + // note this validator starts not-bonded validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, startTokens) - require.Equal(t, startTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) - validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) - require.Equal(t, startTokens, pool.BondedTokens) - require.Equal(t, startTokens, validator.BondedTokens()) + validator, issuedShares := validator.AddTokensFromDel(startTokens) + require.Equal(t, startTokens, issuedShares.RoundInt()) + + validator = TestingUpdateValidator(keeper, ctx, validator, true) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) @@ -197,37 +197,41 @@ func TestUnbondDelegation(t *testing.T) { require.True(t, found) validator, found = keeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - pool = keeper.GetPool(ctx) remainingTokens := startTokens.Sub(bondTokens) require.Equal(t, remainingTokens, delegation.Shares.RoundInt()) require.Equal(t, remainingTokens, validator.BondedTokens()) - require.Equal(t, bondTokens, pool.NotBondedTokens, "%v", pool) - require.Equal(t, remainingTokens, pool.BondedTokens) } func TestUnbondingDelegationsMaxEntries(t *testing.T) { - ctx, ak, keeper := CreateTestInput(t, false, 1) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 1) startTokens := sdk.TokensFromConsensusPower(10) - pool.NotBondedTokens = startTokens + bondDenom := keeper.BondDenom(ctx) + + bondedPool := keeper.GetBondedPool(ctx) + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(bondDenom, startTokens))) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) // create a validator and a delegator to that validator validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, startTokens) - require.Equal(t, startTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) - validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) - require.Equal(t, startTokens, pool.BondedTokens) - require.Equal(t, startTokens, validator.BondedTokens()) + validator, issuedShares := validator.AddTokensFromDel(startTokens) + require.Equal(t, startTokens, issuedShares.RoundInt()) + + validator = TestingUpdateValidator(keeper, ctx, validator, true) + require.True(sdk.IntEq(t, startTokens, validator.BondedTokens())) + require.True(t, validator.IsBonded()) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) maxEntries := keeper.MaxEntries(ctx) + oldBonded := keeper.GetBondedPool(ctx).GetCoins().AmountOf(bondDenom) + oldNotBonded := keeper.GetNotBondedPool(ctx).GetCoins().AmountOf(bondDenom) + // should all pass var completionTime time.Time for i := uint16(0); i < maxEntries; i++ { @@ -236,87 +240,97 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) { require.NoError(t, err) } - // delegator shares should be reduced by 7 - delegator, _ := keeper.GetDelegation(ctx, addrDels[0], addrVals[0]) - require.Equal(t, sdk.NewDec(9999993), delegator.GetShares()) + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded.SubRaw(int64(maxEntries)))) + require.True(sdk.IntEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded.AddRaw(int64(maxEntries)))) - acc := ak.GetAccount(ctx, addrDels[0]) - require.Equal(t, int64(1000000), acc.GetCoins().AmountOf("stake").Int64()) + oldBonded = bondedPool.GetCoins().AmountOf(bondDenom) + oldNotBonded = notBondedPool.GetCoins().AmountOf(bondDenom) // an additional unbond should fail due to max entries - _, err := keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(1)) + _, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(1)) require.Error(t, err) - // delegator shares should not reduced - delegator, _ = keeper.GetDelegation(ctx, addrDels[0], addrVals[0]) - require.Equal(t, sdk.NewDec(9999993), delegator.GetShares()) + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded)) + require.True(sdk.IntEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded)) // mature unbonding delegations ctx = ctx.WithBlockTime(completionTime) err = keeper.CompleteUnbonding(ctx, addrDels[0], addrVals[0]) require.NoError(t, err) - // delegator account balance should be increased by 7 - acc = ak.GetAccount(ctx, addrDels[0]) - require.Equal(t, int64(1000007), acc.GetCoins().AmountOf("stake").Int64()) + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded)) + require.True(sdk.IntEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded.SubRaw(int64(maxEntries)))) - completionTime, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(3)) - require.NoError(t, err) - - // delegator shares should be reduced by 3 - dele2, _ := keeper.GetDelegation(ctx, addrDels[0], addrVals[0]) - require.Equal(t, sdk.NewDec(9999990), dele2.GetShares()) - - // mature unbonding delegations - ctx = ctx.WithBlockTime(completionTime) - err = keeper.CompleteUnbonding(ctx, addrDels[0], addrVals[0]) - require.NoError(t, err) - - // delegator account balance should be increased by 3 - acc = ak.GetAccount(ctx, addrDels[0]) - require.Equal(t, int64(1000010), acc.GetCoins().AmountOf("stake").Int64()) + oldNotBonded = notBondedPool.GetCoins().AmountOf(bondDenom) // unbonding should work again _, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(1)) require.NoError(t, err) + + bondedPool = keeper.GetBondedPool(ctx) + + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, bondedPool.GetCoins().AmountOf(bondDenom), oldBonded.SubRaw(1))) + require.True(sdk.IntEq(t, notBondedPool.GetCoins().AmountOf(bondDenom), oldNotBonded.AddRaw(1))) } // test undelegating self delegation from a validator pushing it below MinSelfDelegation // shift it from the bonded to unbonding state and jailed func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) - startTokens := sdk.TokensFromConsensusPower(20) - pool.NotBondedTokens = startTokens + ctx, _, keeper, _ := CreateTestInput(t, false, 0) + delTokens := sdk.TokensFromConsensusPower(10) + delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens)) //create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) - valTokens := sdk.TokensFromConsensusPower(10) - validator.MinSelfDelegation = valTokens - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) - require.Equal(t, valTokens, issuedShares.RoundInt()) + validator.MinSelfDelegation = delTokens + validator, issuedShares := validator.AddTokensFromDel(delTokens) + require.Equal(t, delTokens, issuedShares.RoundInt()) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) + selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) + // add bonded tokens to pool for delegations + bondedPool := keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + // create a second delegation to this validator keeper.DeleteValidatorByPowerIndex(ctx, validator) - delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + validator, issuedShares = validator.AddTokensFromDel(delTokens) + require.True(t, validator.IsBonded()) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) + + // add bonded tokens to pool for delegations + bondedPool = keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) - _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6).ToDec()) + _, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6).ToDec()) require.NoError(t, err) // end block @@ -331,34 +345,53 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) { } func TestUndelegateFromUnbondingValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) - startTokens := sdk.TokensFromConsensusPower(20) - pool.NotBondedTokens = startTokens + ctx, _, keeper, _ := CreateTestInput(t, false, 0) + delTokens := sdk.TokensFromConsensusPower(10) + delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens)) //create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) - valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) - require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) + validator, issuedShares := validator.AddTokensFromDel(delTokens) + require.Equal(t, delTokens, issuedShares.RoundInt()) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) + selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) + bondedPool := keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + // create a second delegation to this validator keeper.DeleteValidatorByPowerIndex(ctx, validator) - delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + + validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) + + bondedPool = keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) + bondedPool = keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + header := ctx.BlockHeader() blockHeight := int64(10) header.Height = blockHeight @@ -368,7 +401,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) { // unbond the all self-delegation to put validator in unbonding state val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) - _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec()) + _, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec()) require.NoError(t, err) // end block @@ -400,32 +433,40 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) { } func TestUndelegateFromUnbondedValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1) - pool := keeper.GetPool(ctx) - startTokens := sdk.TokensFromConsensusPower(20) - pool.NotBondedTokens = startTokens + ctx, _, keeper, _ := CreateTestInput(t, false, 1) + delTokens := sdk.TokensFromConsensusPower(10) + delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) // create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) + val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) + bondedPool := keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + // create a second delegation to this validator keeper.DeleteValidatorByPowerIndex(ctx, validator) - delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) @@ -433,7 +474,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) { ctx = ctx.WithBlockTime(time.Unix(333, 0)) // unbond the all self-delegation to put validator in unbonding state - _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec()) + _, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec()) require.NoError(t, err) // end block @@ -471,32 +512,43 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) { } func TestUnbondingAllDelegationFromValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) - startTokens := sdk.TokensFromConsensusPower(20) - pool.NotBondedTokens = startTokens + ctx, _, keeper, _ := CreateTestInput(t, false, 0) + delTokens := sdk.TokensFromConsensusPower(10) + delCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), delTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) //create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) + validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) + selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) // create a second delegation to this validator keeper.DeleteValidatorByPowerIndex(ctx, validator) - delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) + + bondedPool := keeper.GetBondedPool(ctx) + err = bondedPool.SetCoins(bondedPool.GetCoins().Add(delCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) + delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) @@ -504,7 +556,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) { ctx = ctx.WithBlockTime(time.Unix(333, 0)) // unbond the all self-delegation to put validator in unbonding state - _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec()) + _, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], valTokens.ToDec()) require.NoError(t, err) // end block @@ -530,8 +582,8 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) { } // Make sure that that the retrieving the delegations doesn't affect the state -func TestGetRedelegationsFromValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) +func TestGetRedelegationsFromSrcValidator(t *testing.T) { + ctx, _, keeper, _ := CreateTestInput(t, false, 0) rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0, time.Unix(0, 0), sdk.NewInt(5), @@ -543,19 +595,19 @@ func TestGetRedelegationsFromValidator(t *testing.T) { require.True(t, found) // get the redelegations one time - redelegations := keeper.GetRedelegationsFromValidator(ctx, addrVals[0]) + redelegations := keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0]) require.Equal(t, 1, len(redelegations)) require.True(t, redelegations[0].Equal(resBond)) // get the redelegations a second time, should be exactly the same - redelegations = keeper.GetRedelegationsFromValidator(ctx, addrVals[0]) + redelegations = keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0]) require.Equal(t, 1, len(redelegations)) require.True(t, redelegations[0].Equal(resBond)) } // tests Get/Set/Remove/Has UnbondingDelegation func TestRedelegation(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0, time.Unix(0, 0), sdk.NewInt(5), @@ -570,7 +622,7 @@ func TestRedelegation(t *testing.T) { resRed, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1]) require.True(t, found) - redelegations := keeper.GetRedelegationsFromValidator(ctx, addrVals[0]) + redelegations := keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0]) require.Equal(t, 1, len(redelegations)) require.True(t, redelegations[0].Equal(resRed)) @@ -594,7 +646,7 @@ func TestRedelegation(t *testing.T) { require.True(t, found) require.True(t, rd.Equal(resRed)) - redelegations = keeper.GetRedelegationsFromValidator(ctx, addrVals[0]) + redelegations = keeper.GetRedelegationsFromSrcValidator(ctx, addrVals[0]) require.Equal(t, 1, len(redelegations)) require.True(t, redelegations[0].Equal(resRed)) @@ -615,52 +667,58 @@ func TestRedelegation(t *testing.T) { } func TestRedelegateToSameValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) - startTokens := sdk.TokensFromConsensusPower(30) - pool.NotBondedTokens = startTokens + ctx, _, keeper, _ := CreateTestInput(t, false, 0) + valTokens := sdk.TokensFromConsensusPower(10) + startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), valTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) // create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) - valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + require.True(t, validator.IsBonded()) + val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) - _, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[0], sdk.NewDec(5)) + _, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[0], sdk.NewDec(5)) require.Error(t, err) } func TestRedelegationMaxEntries(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) startTokens := sdk.TokensFromConsensusPower(20) - pool.NotBondedTokens = startTokens + startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) // create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) // create a second validator validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{}) - validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens) + validator2, issuedShares = validator2.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - pool.BondedTokens = pool.BondedTokens.Add(valTokens) - keeper.SetPool(ctx, pool) + validator2 = TestingUpdateValidator(keeper, ctx, validator2, true) require.Equal(t, sdk.Bonded, validator2.Status) @@ -675,7 +733,7 @@ func TestRedelegationMaxEntries(t *testing.T) { } // an additional redelegation should fail due to max entries - _, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(1)) + _, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(1)) require.Error(t, err) // mature redelegations @@ -689,44 +747,45 @@ func TestRedelegationMaxEntries(t *testing.T) { } func TestRedelegateSelfDelegation(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) startTokens := sdk.TokensFromConsensusPower(30) - pool.NotBondedTokens = startTokens + startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) //create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) + validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) + val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) // create a second validator validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{}) - validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens) + validator2, issuedShares = validator2.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - pool.BondedTokens = pool.BondedTokens.Add(valTokens) - keeper.SetPool(ctx, pool) validator2 = TestingUpdateValidator(keeper, ctx, validator2, true) require.Equal(t, sdk.Bonded, validator2.Status) // create a second delegation to validator 1 delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) - _, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], delTokens.ToDec()) + _, err = keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], delTokens.ToDec()) require.NoError(t, err) // end block @@ -740,20 +799,23 @@ func TestRedelegateSelfDelegation(t *testing.T) { } func TestRedelegateFromUnbondingValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) startTokens := sdk.TokensFromConsensusPower(30) - pool.NotBondedTokens = startTokens + startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) //create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) @@ -761,19 +823,16 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) { // create a second delegation to this validator keeper.DeleteValidatorByPowerIndex(ctx, validator) delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) // create a second validator validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{}) - validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens) + validator2, issuedShares = validator2.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator2 = TestingUpdateValidator(keeper, ctx, validator2, true) header := ctx.BlockHeader() @@ -784,7 +843,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) { ctx = ctx.WithBlockHeader(header) // unbond the all self-delegation to put validator in unbonding state - _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec()) + _, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec()) require.NoError(t, err) // end block @@ -819,20 +878,23 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) { } func TestRedelegateFromUnbondedValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) startTokens := sdk.TokensFromConsensusPower(30) - pool.NotBondedTokens = startTokens + startCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), startTokens)) + + // add bonded tokens to pool for delegations + notBondedPool := keeper.GetNotBondedPool(ctx) + err := notBondedPool.SetCoins(notBondedPool.GetCoins().Add(startCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) //create a validator with a self-delegation validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens) + validator, issuedShares := validator.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares) keeper.SetDelegation(ctx, selfDelegation) @@ -840,19 +902,16 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { // create a second delegation to this validator keeper.DeleteValidatorByPowerIndex(ctx, validator) delTokens := sdk.TokensFromConsensusPower(10) - validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens) + validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(t, delTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator = TestingUpdateValidator(keeper, ctx, validator, true) - pool = keeper.GetPool(ctx) delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) // create a second validator validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{}) - validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens) + validator2, issuedShares = validator2.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) - keeper.SetPool(ctx, pool) validator2 = TestingUpdateValidator(keeper, ctx, validator2, true) require.Equal(t, sdk.Bonded, validator2.Status) @@ -860,7 +919,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { ctx = ctx.WithBlockTime(time.Unix(333, 0)) // unbond the all self-delegation to put validator in unbonding state - _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec()) + _, err = keeper.Undelegate(ctx, val0AccAddr, addrVals[0], delTokens.ToDec()) require.NoError(t, err) // end block diff --git a/x/staking/keeper/invariants.go b/x/staking/keeper/invariants.go index 9dfe6b8b1..7339eddc0 100644 --- a/x/staking/keeper/invariants.go +++ b/x/staking/keeper/invariants.go @@ -5,17 +5,15 @@ import ( "fmt" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/staking/exported" "github.com/cosmos/cosmos-sdk/x/staking/types" ) -// register all staking invariants -func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper, f types.FeeCollectionKeeper, - d types.DistributionKeeper, am types.AccountKeeper) { +// RegisterInvariants registers all staking invariants +func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper) { - ir.RegisterRoute(types.ModuleName, "supply", - SupplyInvariants(k, f, d, am)) + ir.RegisterRoute(types.ModuleName, "module-accounts", + ModuleAccountInvariants(k)) ir.RegisterRoute(types.ModuleName, "nonnegative-power", NonNegativePowerInvariant(k)) ir.RegisterRoute(types.ModuleName, "positive-delegation", @@ -25,11 +23,10 @@ func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper, f types.FeeCollectio } // AllInvariants runs all invariants of the staking module. -func AllInvariants(k Keeper, f types.FeeCollectionKeeper, - d types.DistributionKeeper, am types.AccountKeeper) sdk.Invariant { +func AllInvariants(k Keeper) sdk.Invariant { return func(ctx sdk.Context) error { - err := SupplyInvariants(k, f, d, am)(ctx) + err := ModuleAccountInvariants(k)(ctx) if err != nil { return err } @@ -44,66 +41,57 @@ func AllInvariants(k Keeper, f types.FeeCollectionKeeper, return err } - err = DelegatorSharesInvariant(k)(ctx) - if err != nil { - return err - } - - return nil + return DelegatorSharesInvariant(k)(ctx) } } -// SupplyInvariants checks that the total supply reflects all held not-bonded tokens, bonded tokens, and unbonding delegations -// nolint: unparam -func SupplyInvariants(k Keeper, f types.FeeCollectionKeeper, - d types.DistributionKeeper, am types.AccountKeeper) sdk.Invariant { - +// ModuleAccountInvariants checks that the bonded and notBonded ModuleAccounts pools +// reflects the tokens actively bonded and not bonded +func ModuleAccountInvariants(k Keeper) sdk.Invariant { return func(ctx sdk.Context) error { - pool := k.GetPool(ctx) + bonded := sdk.ZeroInt() + notBonded := sdk.ZeroInt() + bondedPool := k.GetBondedPool(ctx) + notBondedPool := k.GetNotBondedPool(ctx) + bondDenom := k.BondDenom(ctx) - loose := sdk.ZeroDec() - bonded := sdk.ZeroDec() - am.IterateAccounts(ctx, func(acc auth.Account) bool { - loose = loose.Add(acc.GetCoins().AmountOf(k.BondDenom(ctx)).ToDec()) - return false - }) - k.IterateUnbondingDelegations(ctx, func(_ int64, ubd types.UnbondingDelegation) bool { - for _, entry := range ubd.Entries { - loose = loose.Add(entry.Balance.ToDec()) - } - return false - }) k.IterateValidators(ctx, func(_ int64, validator exported.ValidatorI) bool { switch validator.GetStatus() { case sdk.Bonded: - bonded = bonded.Add(validator.GetBondedTokens().ToDec()) + bonded = bonded.Add(validator.GetTokens()) case sdk.Unbonding, sdk.Unbonded: - loose = loose.Add(validator.GetTokens().ToDec()) + notBonded = notBonded.Add(validator.GetTokens()) + default: + panic("invalid validator status") } - // add yet-to-be-withdrawn - loose = loose.Add(d.GetValidatorOutstandingRewardsCoins(ctx, validator.GetOperator()).AmountOf(k.BondDenom(ctx))) return false }) - // add outstanding fees - loose = loose.Add(f.GetCollectedFees(ctx).AmountOf(k.BondDenom(ctx)).ToDec()) + k.IterateUnbondingDelegations(ctx, func(_ int64, ubd types.UnbondingDelegation) bool { + for _, entry := range ubd.Entries { + notBonded = notBonded.Add(entry.Balance) + } + return false + }) - // add community pool - loose = loose.Add(d.GetFeePoolCommunityCoins(ctx).AmountOf(k.BondDenom(ctx))) - - // Not-bonded tokens should equal coin supply plus unbonding delegations - // plus tokens on unbonded validators - if !pool.NotBondedTokens.ToDec().Equal(loose) { - return fmt.Errorf("loose token invariance:\n"+ - "\tpool.NotBondedTokens: %v\n"+ - "\tsum of account tokens: %v", pool.NotBondedTokens, loose) - } + poolBonded := bondedPool.GetCoins().AmountOf(bondDenom) + poolNotBonded := notBondedPool.GetCoins().AmountOf(bondDenom) // Bonded tokens should equal sum of tokens with bonded validators - if !pool.BondedTokens.ToDec().Equal(bonded) { - return fmt.Errorf("bonded token invariance:\n"+ - "\tpool.BondedTokens: %v\n"+ - "\tsum of account tokens: %v", pool.BondedTokens, bonded) + // Not-bonded tokens should equal unbonding delegations plus tokens on unbonded validators + if !poolBonded.Equal(bonded) || !poolNotBonded.Equal(notBonded) { + return fmt.Errorf( + "bonded token invariance:\n"+ + "\tPool's bonded tokens: %v\n"+ + "\tsum of bonded tokens: %v\n"+ + "not bonded token invariance:\n"+ + "\tPool's not bonded tokens: %v\n"+ + "\tsum of not bonded tokens: %v\n"+ + "module accounts total (bonded + not bonded):\n"+ + "\tModule Accounts' tokens: %v\n"+ + "\tsum tokens: %v\n", + poolBonded, bonded, poolNotBonded, notBonded, poolBonded.Add(poolNotBonded), bonded.Add(notBonded), + ) } return nil diff --git a/x/staking/keeper/keeper.go b/x/staking/keeper/keeper.go index 28a5b59a1..456f972f0 100644 --- a/x/staking/keeper/keeper.go +++ b/x/staking/keeper/keeper.go @@ -25,7 +25,7 @@ type Keeper struct { storeKey sdk.StoreKey storeTKey sdk.StoreKey cdc *codec.Codec - bankKeeper types.BankKeeper + supplyKeeper types.SupplyKeeper hooks types.StakingHooks paramstore params.Subspace validatorCache map[string]cachedValidator @@ -35,21 +35,30 @@ type Keeper struct { codespace sdk.CodespaceType } -func NewKeeper(cdc *codec.Codec, key, tkey sdk.StoreKey, bk types.BankKeeper, +// NewKeeper creates a new staking Keeper instance +func NewKeeper(cdc *codec.Codec, key, tkey sdk.StoreKey, supplyKeeper types.SupplyKeeper, paramstore params.Subspace, codespace sdk.CodespaceType) Keeper { - keeper := Keeper{ + // ensure bonded and not bonded module accounts are set + if addr := supplyKeeper.GetModuleAddress(types.BondedPoolName); addr == nil { + panic(fmt.Sprintf("%s module account has not been set", types.BondedPoolName)) + } + + if addr := supplyKeeper.GetModuleAddress(types.NotBondedPoolName); addr == nil { + panic(fmt.Sprintf("%s module account has not been set", types.NotBondedPoolName)) + } + + return Keeper{ storeKey: key, storeTKey: tkey, cdc: cdc, - bankKeeper: bk, + supplyKeeper: supplyKeeper, paramstore: paramstore.WithKeyTable(ParamKeyTable()), hooks: nil, validatorCache: make(map[string]cachedValidator, aminoCacheSize), validatorCacheList: list.New(), codespace: codespace, } - return keeper } // Logger returns a module-specific logger. @@ -71,24 +80,6 @@ func (k Keeper) Codespace() sdk.CodespaceType { return k.codespace } -// get the pool -func (k Keeper) GetPool(ctx sdk.Context) (pool types.Pool) { - store := ctx.KVStore(k.storeKey) - b := store.Get(types.PoolKey) - if b == nil { - panic("stored pool should not have been nil") - } - k.cdc.MustUnmarshalBinaryLengthPrefixed(b, &pool) - return -} - -// set the pool -func (k Keeper) SetPool(ctx sdk.Context, pool types.Pool) { - store := ctx.KVStore(k.storeKey) - b := k.cdc.MustMarshalBinaryLengthPrefixed(pool) - store.Set(types.PoolKey, b) -} - // Load the last total validator power. func (k Keeper) GetLastTotalPower(ctx sdk.Context) (power sdk.Int) { store := ctx.KVStore(k.storeKey) diff --git a/x/staking/keeper/keeper_test.go b/x/staking/keeper/keeper_test.go index 30feb8b28..eb9d16459 100644 --- a/x/staking/keeper/keeper_test.go +++ b/x/staking/keeper/keeper_test.go @@ -5,12 +5,11 @@ import ( "github.com/stretchr/testify/require" - sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking/types" ) func TestParams(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) expParams := types.DefaultParams() //check that the empty keeper loads the default @@ -23,18 +22,3 @@ func TestParams(t *testing.T) { resParams = keeper.GetParams(ctx) require.True(t, expParams.Equal(resParams)) } - -func TestPool(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - expPool := types.InitialPool() - - //check that the empty keeper loads the default - resPool := keeper.GetPool(ctx) - require.Equal(t, expPool, resPool) - - //modify a params, save, and retrieve - expPool.BondedTokens = sdk.NewInt(777) - keeper.SetPool(ctx, expPool) - resPool = keeper.GetPool(ctx) - require.Equal(t, expPool, resPool) -} diff --git a/x/staking/keeper/pool.go b/x/staking/keeper/pool.go new file mode 100644 index 000000000..5f9ff0535 --- /dev/null +++ b/x/staking/keeper/pool.go @@ -0,0 +1,75 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/cosmos/cosmos-sdk/x/supply/exported" +) + +// GetBondedPool returns the bonded tokens pool's module account +func (k Keeper) GetBondedPool(ctx sdk.Context) (bondedPool exported.ModuleAccountI) { + return k.supplyKeeper.GetModuleAccount(ctx, types.BondedPoolName) +} + +// GetNotBondedPool returns the not bonded tokens pool's module account +func (k Keeper) GetNotBondedPool(ctx sdk.Context) (notBondedPool exported.ModuleAccountI) { + return k.supplyKeeper.GetModuleAccount(ctx, types.NotBondedPoolName) +} + +// bondedTokensToNotBonded transfers coins from the bonded to the not bonded pool within staking +func (k Keeper) bondedTokensToNotBonded(ctx sdk.Context, tokens sdk.Int) { + coins := sdk.NewCoins(sdk.NewCoin(k.BondDenom(ctx), tokens)) + err := k.supplyKeeper.SendCoinsFromModuleToModule(ctx, types.BondedPoolName, types.NotBondedPoolName, coins) + if err != nil { + panic(err) + } +} + +// notBondedTokensToBonded transfers coins from the not bonded to the bonded pool within staking +func (k Keeper) notBondedTokensToBonded(ctx sdk.Context, tokens sdk.Int) { + coins := sdk.NewCoins(sdk.NewCoin(k.BondDenom(ctx), tokens)) + err := k.supplyKeeper.SendCoinsFromModuleToModule(ctx, types.NotBondedPoolName, types.BondedPoolName, coins) + if err != nil { + panic(err) + } +} + +// burnBondedTokens removes coins from the bonded pool module account +func (k Keeper) burnBondedTokens(ctx sdk.Context, amt sdk.Int) sdk.Error { + if !amt.IsPositive() { + return nil + } + coins := sdk.NewCoins(sdk.NewCoin(k.BondDenom(ctx), amt)) + return k.supplyKeeper.BurnCoins(ctx, types.BondedPoolName, coins) +} + +// burnNotBondedTokens removes coins from the not bonded pool module account +func (k Keeper) burnNotBondedTokens(ctx sdk.Context, amt sdk.Int) sdk.Error { + if !amt.IsPositive() { + return nil + } + coins := sdk.NewCoins(sdk.NewCoin(k.BondDenom(ctx), amt)) + return k.supplyKeeper.BurnCoins(ctx, types.NotBondedPoolName, coins) +} + +// TotalBondedTokens total staking tokens supply which is bonded +func (k Keeper) TotalBondedTokens(ctx sdk.Context) sdk.Int { + bondedPool := k.GetBondedPool(ctx) + return bondedPool.GetCoins().AmountOf(k.BondDenom(ctx)) +} + +// StakingTokenSupply staking tokens from the total supply +func (k Keeper) StakingTokenSupply(ctx sdk.Context) sdk.Int { + return k.supplyKeeper.GetSupply(ctx).Total.AmountOf(k.BondDenom(ctx)) +} + +// BondedRatio the fraction of the staking tokens which are currently bonded +func (k Keeper) BondedRatio(ctx sdk.Context) sdk.Dec { + bondedPool := k.GetBondedPool(ctx) + + stakeSupply := k.StakingTokenSupply(ctx) + if stakeSupply.IsPositive() { + return bondedPool.GetCoins().AmountOf(k.BondDenom(ctx)).ToDec().QuoInt(stakeSupply) + } + return sdk.ZeroDec() +} diff --git a/x/staking/keeper/querier.go b/x/staking/keeper/querier.go index d68e9679b..0feb465e0 100644 --- a/x/staking/keeper/querier.go +++ b/x/staking/keeper/querier.go @@ -298,7 +298,7 @@ func queryRedelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byt redels = []types.Redelegation{redel} } else if params.DelegatorAddr.Empty() && !params.SrcValidatorAddr.Empty() && params.DstValidatorAddr.Empty() { - redels = k.GetRedelegationsFromValidator(ctx, params.SrcValidatorAddr) + redels = k.GetRedelegationsFromSrcValidator(ctx, params.SrcValidatorAddr) } else { redels = k.GetAllRedelegations(ctx, params.DelegatorAddr, params.SrcValidatorAddr, params.DstValidatorAddr) } @@ -317,7 +317,17 @@ func queryRedelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byt } func queryPool(ctx sdk.Context, k Keeper) ([]byte, sdk.Error) { - pool := k.GetPool(ctx) + bondDenom := k.BondDenom(ctx) + bondedPool := k.GetBondedPool(ctx) + notBondedPool := k.GetNotBondedPool(ctx) + if bondedPool == nil || notBondedPool == nil { + return nil, sdk.ErrInternal("pool accounts haven't been set") + } + + pool := types.NewPool( + notBondedPool.GetCoins().AmountOf(bondDenom), + bondedPool.GetCoins().AmountOf(bondDenom), + ) res, err := codec.MarshalJSONIndent(types.ModuleCdc, pool) if err != nil { diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go index 4e8cee4ea..039002e9f 100644 --- a/x/staking/keeper/querier_test.go +++ b/x/staking/keeper/querier_test.go @@ -20,25 +20,23 @@ var ( func TestNewQuerier(t *testing.T) { cdc := codec.New() - ctx, _, r := CreateTestInput(t, false, 1000) - pool := r.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) // Create Validators amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8)} var validators [2]types.Validator for i, amt := range amts { validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt) - r.SetValidator(ctx, validators[i]) - r.SetValidatorByPowerIndex(ctx, validators[i]) + validators[i], _ = validators[i].AddTokensFromDel(amt) + keeper.SetValidator(ctx, validators[i]) + keeper.SetValidatorByPowerIndex(ctx, validators[i]) } - r.SetPool(ctx, pool) query := abci.RequestQuery{ Path: "", Data: []byte{}, } - querier := NewQuerier(r) + querier := NewQuerier(keeper) bz, err := querier(ctx, []string{"other"}, query) require.NotNil(t, err) @@ -92,30 +90,33 @@ func TestNewQuerier(t *testing.T) { func TestQueryParametersPool(t *testing.T) { cdc := codec.New() - ctx, _, r := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) + bondDenom := keeper.BondDenom(ctx) - res, err := queryParameters(ctx, r) + res, err := queryParameters(ctx, keeper) require.Nil(t, err) var params types.Params errRes := cdc.UnmarshalJSON(res, ¶ms) require.Nil(t, errRes) - require.Equal(t, r.GetParams(ctx), params) + require.Equal(t, keeper.GetParams(ctx), params) - res, err = queryPool(ctx, r) + res, err = queryPool(ctx, keeper) require.Nil(t, err) var pool types.Pool + bondedPool := keeper.GetBondedPool(ctx) + notBondedPool := keeper.GetNotBondedPool(ctx) errRes = cdc.UnmarshalJSON(res, &pool) require.Nil(t, errRes) - require.Equal(t, r.GetPool(ctx), pool) + require.Equal(t, bondedPool.GetCoins().AmountOf(bondDenom), pool.BondedTokens) + require.Equal(t, notBondedPool.GetCoins().AmountOf(bondDenom), pool.NotBondedTokens) } func TestQueryValidators(t *testing.T) { cdc := codec.New() - ctx, _, r := CreateTestInput(t, false, 10000) - pool := r.GetPool(ctx) - params := r.GetParams(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 10000) + params := keeper.GetParams(ctx) // Create Validators amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} @@ -123,17 +124,16 @@ func TestQueryValidators(t *testing.T) { var validators [3]types.Validator for i, amt := range amts { validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, amt) - validators[i], pool = validators[i].UpdateStatus(pool, status[i]) + validators[i], _ = validators[i].AddTokensFromDel(amt) + validators[i] = validators[i].UpdateStatus(status[i]) } - r.SetPool(ctx, pool) - r.SetValidator(ctx, validators[0]) - r.SetValidator(ctx, validators[1]) - r.SetValidator(ctx, validators[2]) + keeper.SetValidator(ctx, validators[0]) + keeper.SetValidator(ctx, validators[1]) + keeper.SetValidator(ctx, validators[2]) // Query Validators - queriedValidators := r.GetValidators(ctx, params.MaxValidators) + queriedValidators := keeper.GetValidators(ctx, params.MaxValidators) for i, s := range status { queryValsParams := types.NewQueryValidatorsParams(1, int(params.MaxValidators), s.String()) @@ -145,7 +145,7 @@ func TestQueryValidators(t *testing.T) { Data: bz, } - res, err := queryValidators(ctx, req, r) + res, err := queryValidators(ctx, req, keeper) require.Nil(t, err) var validatorsResp []types.Validator @@ -166,7 +166,7 @@ func TestQueryValidators(t *testing.T) { Path: "/custom/staking/validator", Data: bz, } - res, err := queryValidator(ctx, query, r) + res, err := queryValidator(ctx, query, keeper) require.Nil(t, err) var validator types.Validator @@ -178,23 +178,23 @@ func TestQueryValidators(t *testing.T) { func TestQueryDelegation(t *testing.T) { cdc := codec.New() - ctx, _, r := CreateTestInput(t, false, 10000) - params := r.GetParams(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 10000) + params := keeper.GetParams(ctx) // Create Validators and Delegation val1 := types.NewValidator(addrVal1, pk1, types.Description{}) - r.SetValidator(ctx, val1) - r.SetValidatorByPowerIndex(ctx, val1) + keeper.SetValidator(ctx, val1) + keeper.SetValidatorByPowerIndex(ctx, val1) val2 := types.NewValidator(addrVal2, pk2, types.Description{}) - r.SetValidator(ctx, val2) - r.SetValidatorByPowerIndex(ctx, val2) + keeper.SetValidator(ctx, val2) + keeper.SetValidatorByPowerIndex(ctx, val2) delTokens := sdk.TokensFromConsensusPower(20) - r.Delegate(ctx, addrAcc2, delTokens, val1, true) + keeper.Delegate(ctx, addrAcc2, delTokens, sdk.Unbonded, val1, true) // apply TM updates - r.ApplyAndReturnValidatorSetUpdates(ctx) + keeper.ApplyAndReturnValidatorSetUpdates(ctx) // Query Delegator bonded validators queryParams := types.NewQueryDelegatorParams(addrAcc2) @@ -206,9 +206,9 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - delValidators := r.GetDelegatorValidators(ctx, addrAcc2, params.MaxValidators) + delValidators := keeper.GetDelegatorValidators(ctx, addrAcc2, params.MaxValidators) - res, err := queryDelegatorValidators(ctx, query, r) + res, err := queryDelegatorValidators(ctx, query, keeper) require.Nil(t, err) var validatorsResp []types.Validator @@ -221,7 +221,7 @@ func TestQueryDelegation(t *testing.T) { // error unknown request query.Data = bz[:len(bz)-1] - _, err = queryDelegatorValidators(ctx, query, r) + _, err = queryDelegatorValidators(ctx, query, keeper) require.NotNil(t, err) // Query bonded validator @@ -234,7 +234,7 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - res, err = queryDelegatorValidator(ctx, query, r) + res, err = queryDelegatorValidator(ctx, query, keeper) require.Nil(t, err) var validator types.Validator @@ -246,7 +246,7 @@ func TestQueryDelegation(t *testing.T) { // error unknown request query.Data = bz[:len(bz)-1] - _, err = queryDelegatorValidator(ctx, query, r) + _, err = queryDelegatorValidator(ctx, query, keeper) require.NotNil(t, err) // Query delegation @@ -256,10 +256,10 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - delegation, found := r.GetDelegation(ctx, addrAcc2, addrVal1) + delegation, found := keeper.GetDelegation(ctx, addrAcc2, addrVal1) require.True(t, found) - res, err = queryDelegation(ctx, query, r) + res, err = queryDelegation(ctx, query, keeper) require.Nil(t, err) var delegationRes types.DelegationResponse @@ -276,7 +276,7 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - res, err = queryDelegatorDelegations(ctx, query, r) + res, err = queryDelegatorDelegations(ctx, query, keeper) require.Nil(t, err) var delegatorDelegations types.DelegationResponses @@ -290,7 +290,7 @@ func TestQueryDelegation(t *testing.T) { // error unknown request query.Data = bz[:len(bz)-1] - _, err = queryDelegation(ctx, query, r) + _, err = queryDelegation(ctx, query, keeper) require.NotNil(t, err) // Query validator delegations @@ -303,7 +303,7 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - res, err = queryValidatorDelegations(ctx, query, r) + res, err = queryValidatorDelegations(ctx, query, keeper) require.Nil(t, err) var delegationsRes types.DelegationResponses @@ -316,7 +316,7 @@ func TestQueryDelegation(t *testing.T) { // Query unbonging delegation unbondingTokens := sdk.TokensFromConsensusPower(10) - _, err = r.Undelegate(ctx, addrAcc2, val1.OperatorAddress, unbondingTokens.ToDec()) + _, err = keeper.Undelegate(ctx, addrAcc2, val1.OperatorAddress, unbondingTokens.ToDec()) require.Nil(t, err) queryBondParams = types.NewQueryBondsParams(addrAcc2, addrVal1) @@ -328,10 +328,10 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - unbond, found := r.GetUnbondingDelegation(ctx, addrAcc2, addrVal1) + unbond, found := keeper.GetUnbondingDelegation(ctx, addrAcc2, addrVal1) require.True(t, found) - res, err = queryUnbondingDelegation(ctx, query, r) + res, err = queryUnbondingDelegation(ctx, query, keeper) require.Nil(t, err) var unbondRes types.UnbondingDelegation @@ -343,7 +343,7 @@ func TestQueryDelegation(t *testing.T) { // error unknown request query.Data = bz[:len(bz)-1] - _, err = queryUnbondingDelegation(ctx, query, r) + _, err = queryUnbondingDelegation(ctx, query, keeper) require.NotNil(t, err) // Query Delegator Delegations @@ -353,7 +353,7 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - res, err = queryDelegatorUnbondingDelegations(ctx, query, r) + res, err = queryDelegatorUnbondingDelegations(ctx, query, keeper) require.Nil(t, err) var delegatorUbds []types.UnbondingDelegation @@ -364,15 +364,15 @@ func TestQueryDelegation(t *testing.T) { // error unknown request query.Data = bz[:len(bz)-1] - _, err = queryDelegatorUnbondingDelegations(ctx, query, r) + _, err = queryDelegatorUnbondingDelegations(ctx, query, keeper) require.NotNil(t, err) // Query redelegation redelegationTokens := sdk.TokensFromConsensusPower(10) - _, err = r.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddress, + _, err = keeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress, redelegationTokens.ToDec()) require.Nil(t, err) - redel, found := r.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress) + redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress) require.True(t, found) bz, errRes = cdc.MarshalJSON(types.NewQueryRedelegationParams(addrAcc2, val1.OperatorAddress, val2.OperatorAddress)) @@ -383,7 +383,7 @@ func TestQueryDelegation(t *testing.T) { Data: bz, } - res, err = queryRedelegations(ctx, query, r) + res, err = queryRedelegations(ctx, query, keeper) require.Nil(t, err) var redelRes types.RedelegationResponses @@ -398,23 +398,23 @@ func TestQueryDelegation(t *testing.T) { func TestQueryRedelegations(t *testing.T) { cdc := codec.New() - ctx, _, r := CreateTestInput(t, false, 10000) + ctx, _, keeper, _ := CreateTestInput(t, false, 10000) // Create Validators and Delegation val1 := types.NewValidator(addrVal1, pk1, types.Description{}) val2 := types.NewValidator(addrVal2, pk2, types.Description{}) - r.SetValidator(ctx, val1) - r.SetValidator(ctx, val2) + keeper.SetValidator(ctx, val1) + keeper.SetValidator(ctx, val2) delAmount := sdk.TokensFromConsensusPower(100) - r.Delegate(ctx, addrAcc2, delAmount, val1, true) - _ = r.ApplyAndReturnValidatorSetUpdates(ctx) + keeper.Delegate(ctx, addrAcc2, delAmount, sdk.Unbonded, val1, true) + _ = keeper.ApplyAndReturnValidatorSetUpdates(ctx) rdAmount := sdk.TokensFromConsensusPower(20) - r.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) - r.ApplyAndReturnValidatorSetUpdates(ctx) + keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) + keeper.ApplyAndReturnValidatorSetUpdates(ctx) - redel, found := r.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress) + redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress) require.True(t, found) // delegator redelegations @@ -427,7 +427,7 @@ func TestQueryRedelegations(t *testing.T) { Data: bz, } - res, err := queryRedelegations(ctx, query, r) + res, err := queryRedelegations(ctx, query, keeper) require.Nil(t, err) var redelRes types.RedelegationResponses @@ -449,7 +449,7 @@ func TestQueryRedelegations(t *testing.T) { Data: bz, } - res, err = queryRedelegations(ctx, query, r) + res, err = queryRedelegations(ctx, query, keeper) require.Nil(t, err) errRes = cdc.UnmarshalJSON(res, &redelRes) @@ -463,7 +463,7 @@ func TestQueryRedelegations(t *testing.T) { func TestQueryUnbondingDelegation(t *testing.T) { cdc := codec.New() - ctx, _, keeper := CreateTestInput(t, false, 10000) + ctx, _, keeper, _ := CreateTestInput(t, false, 10000) // Create Validators and Delegation val1 := types.NewValidator(addrVal1, pk1, types.Description{}) @@ -471,7 +471,7 @@ func TestQueryUnbondingDelegation(t *testing.T) { // delegate delAmount := sdk.TokensFromConsensusPower(100) - _, err := keeper.Delegate(ctx, addrAcc1, delAmount, val1, true) + _, err := keeper.Delegate(ctx, addrAcc1, delAmount, sdk.Unbonded, val1, true) require.NoError(t, err) _ = keeper.ApplyAndReturnValidatorSetUpdates(ctx) diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go index 6d3cb55aa..6e1c54045 100644 --- a/x/staking/keeper/slash.go +++ b/x/staking/keeper/slash.go @@ -89,8 +89,8 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh remainingSlashAmount = remainingSlashAmount.Sub(amountSlashed) } - // Iterate through redelegations from slashed validator - redelegations := k.GetRedelegationsFromValidator(ctx, operatorAddress) + // Iterate through redelegations from slashed source validator + redelegations := k.GetRedelegationsFromSrcValidator(ctx, operatorAddress) for _, redelegation := range redelegations { amountSlashed := k.slashRedelegation(ctx, validator, redelegation, infractionHeight, slashFactor) if amountSlashed.IsZero() { @@ -116,13 +116,21 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh } // Deduct from validator's bonded tokens and update the validator. - // The deducted tokens are returned to pool.NotBondedTokens. - // TODO: Move the token accounting outside of `RemoveValidatorTokens` so it is less confusing + // Burn the slashed tokens from the pool account and decrease the total supply. validator = k.RemoveValidatorTokens(ctx, validator, tokensToBurn) - pool := k.GetPool(ctx) - // Burn the slashed tokens, which are now loose. - pool.NotBondedTokens = pool.NotBondedTokens.Sub(tokensToBurn) - k.SetPool(ctx, pool) + + switch validator.GetStatus() { + case sdk.Bonded: + if err := k.burnBondedTokens(ctx, tokensToBurn); err != nil { + panic(err) + } + case sdk.Unbonding, sdk.Unbonded: + if err := k.burnNotBondedTokens(ctx, tokensToBurn); err != nil { + panic(err) + } + default: + panic("invalid validator status") + } // Log that a slash occurred! logger.Info(fmt.Sprintf( @@ -163,6 +171,7 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty now := ctx.BlockHeader().Time totalSlashAmount = sdk.ZeroInt() + burnedAmount := sdk.ZeroInt() // perform slashing on all entries within the unbonding delegation for i, entry := range unbondingDelegation.Entries { @@ -192,15 +201,15 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty if unbondingSlashAmount.IsZero() { continue } + + burnedAmount = burnedAmount.Add(unbondingSlashAmount) entry.Balance = entry.Balance.Sub(unbondingSlashAmount) unbondingDelegation.Entries[i] = entry k.SetUnbondingDelegation(ctx, unbondingDelegation) - pool := k.GetPool(ctx) + } - // Burn not-bonded tokens - // Ref https://github.com/cosmos/cosmos-sdk/pull/1278#discussion_r198657760 - pool.NotBondedTokens = pool.NotBondedTokens.Sub(unbondingSlashAmount) - k.SetPool(ctx, pool) + if err := k.burnNotBondedTokens(ctx, burnedAmount); err != nil { + panic(err) } return totalSlashAmount @@ -211,12 +220,13 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty // the unbonding delegation had enough stake to slash // (the amount actually slashed may be less if there's // insufficient stake remaining) -// nolint: unparam -func (k Keeper) slashRedelegation(ctx sdk.Context, validator types.Validator, redelegation types.Redelegation, +// NOTE this is only slashing for prior infractions from the source validator +func (k Keeper) slashRedelegation(ctx sdk.Context, srcValidator types.Validator, redelegation types.Redelegation, infractionHeight int64, slashFactor sdk.Dec) (totalSlashAmount sdk.Int) { now := ctx.BlockHeader().Time totalSlashAmount = sdk.ZeroInt() + bondedBurnedAmount, notBondedBurnedAmount := sdk.ZeroInt(), sdk.ZeroInt() // perform slashing on all entries within the redelegation for _, entry := range redelegation.Entries { @@ -255,10 +265,29 @@ func (k Keeper) slashRedelegation(ctx sdk.Context, validator types.Validator, re panic(fmt.Errorf("error unbonding delegator: %v", err)) } - // Burn not-bonded tokens - pool := k.GetPool(ctx) - pool.NotBondedTokens = pool.NotBondedTokens.Sub(tokensToBurn) - k.SetPool(ctx, pool) + dstValidator, found := k.GetValidator(ctx, redelegation.ValidatorDstAddress) + if !found { + panic("destination validator not found") + } + + // tokens of a redelegation currently live in the destination validator + // therefor we must burn tokens from the destination-validator's bonding status + switch { + case dstValidator.IsBonded(): + bondedBurnedAmount = bondedBurnedAmount.Add(tokensToBurn) + case dstValidator.IsUnbonded() || dstValidator.IsUnbonding(): + notBondedBurnedAmount = notBondedBurnedAmount.Add(tokensToBurn) + default: + panic("unknown validator status") + } + } + + if err := k.burnBondedTokens(ctx, bondedBurnedAmount); err != nil { + panic(err) + } + + if err := k.burnNotBondedTokens(ctx, notBondedBurnedAmount); err != nil { + panic(err) } return totalSlashAmount diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go index 432b8b69c..bd46400ed 100644 --- a/x/staking/keeper/slash_test.go +++ b/x/staking/keeper/slash_test.go @@ -17,23 +17,24 @@ import ( func setupHelper(t *testing.T, power int64) (sdk.Context, Keeper, types.Params) { // setup - ctx, _, keeper := CreateTestInput(t, false, power) + ctx, _, keeper, _ := CreateTestInput(t, false, power) params := keeper.GetParams(ctx) - pool := keeper.GetPool(ctx) numVals := int64(3) amt := sdk.TokensFromConsensusPower(power) - pool.NotBondedTokens = amt.MulRaw(numVals) + bondedCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), amt.MulRaw(numVals))) + + bondedPool := keeper.GetBondedPool(ctx) + err := bondedPool.SetCoins(bondedCoins) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) // add numVals validators for i := int64(0); i < numVals; i++ { validator := types.NewValidator(addrVals[i], PKs[i], types.Description{}) - validator, pool, _ = validator.AddTokensFromDel(pool, amt) - pool.BondedTokens = pool.BondedTokens.Add(amt) - keeper.SetPool(ctx, pool) + validator, _ = validator.AddTokensFromDel(amt) validator = TestingUpdateValidator(keeper, ctx, validator, true) keeper.SetValidatorByConsAddr(ctx, validator) } - pool = keeper.GetPool(ctx) return ctx, keeper, params } @@ -89,7 +90,7 @@ func TestSlashUnbondingDelegation(t *testing.T) { require.Equal(t, int64(0), slashAmount.Int64()) // test valid slash, before expiration timestamp and to which stake contributed - oldPool := keeper.GetPool(ctx) + oldUnbondedPool := keeper.GetNotBondedPool(ctx) ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(0, 0)}) keeper.SetUnbondingDelegation(ctx, ubd) slashAmount = keeper.slashUnbondingDelegation(ctx, ubd, 0, fraction) @@ -103,8 +104,9 @@ func TestSlashUnbondingDelegation(t *testing.T) { // balance decreased require.Equal(t, sdk.NewInt(5), ubd.Entries[0].Balance) - newPool := keeper.GetPool(ctx) - require.Equal(t, int64(5), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens).Int64()) + newUnbondedPool := keeper.GetNotBondedPool(ctx) + diffTokens := oldUnbondedPool.GetCoins().Sub(newUnbondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, int64(5), diffTokens.Int64()) } // tests slashRedelegation @@ -112,6 +114,13 @@ func TestSlashRedelegation(t *testing.T) { ctx, keeper, _ := setupHelper(t, 10) fraction := sdk.NewDecWithPrec(5, 1) + // add bonded tokens to pool for (re)delegations + startCoins := sdk.NewCoins(sdk.NewInt64Coin(keeper.BondDenom(ctx), 15)) + bondedPool := keeper.GetBondedPool(ctx) + err := bondedPool.SetCoins(bondedPool.GetCoins().Add(startCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + // set a redelegation with an expiration timestamp beyond which the // redelegation shouldn't be slashed rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0, @@ -138,7 +147,6 @@ func TestSlashRedelegation(t *testing.T) { require.Equal(t, int64(0), slashAmount.Int64()) // test valid slash, before expiration timestamp and to which stake contributed - oldPool := keeper.GetPool(ctx) ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(0, 0)}) keeper.SetRedelegation(ctx, rd) validator, found = keeper.GetValidator(ctx, addrVals[1]) @@ -161,9 +169,10 @@ func TestSlashRedelegation(t *testing.T) { require.True(t, found) require.Equal(t, int64(5), del.Shares.RoundInt64()) - // pool bonded tokens decreased - newPool := keeper.GetPool(ctx) - require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64()) + // pool bonded tokens should decrease + burnedCoins := sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), slashAmount)) + newBondedPool := keeper.GetBondedPool(ctx) + require.Equal(t, bondedPool.GetCoins().Sub(burnedCoins), newBondedPool.GetCoins()) } // tests Slash at a future height (must panic) @@ -181,7 +190,7 @@ func TestSlashAtNegativeHeight(t *testing.T) { consAddr := sdk.ConsAddress(PKs[0].Address()) fraction := sdk.NewDecWithPrec(5, 1) - oldPool := keeper.GetPool(ctx) + oldBondedPool := keeper.GetBondedPool(ctx) validator, found := keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) keeper.Slash(ctx, consAddr, -2, 10, fraction) @@ -189,7 +198,7 @@ func TestSlashAtNegativeHeight(t *testing.T) { // read updated state validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) - newPool := keeper.GetPool(ctx) + newBondedPool := keeper.GetBondedPool(ctx) // end block updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -199,7 +208,8 @@ func TestSlashAtNegativeHeight(t *testing.T) { // power decreased require.Equal(t, int64(5), validator.GetConsensusPower()) // pool bonded shares decreased - require.Equal(t, sdk.TokensFromConsensusPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens)) + diffTokens := oldBondedPool.GetCoins().Sub(newBondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, sdk.TokensFromConsensusPower(5), diffTokens) } // tests Slash at the current height @@ -208,7 +218,7 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) { consAddr := sdk.ConsAddress(PKs[0].Address()) fraction := sdk.NewDecWithPrec(5, 1) - oldPool := keeper.GetPool(ctx) + oldBondedPool := keeper.GetBondedPool(ctx) validator, found := keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) keeper.Slash(ctx, consAddr, ctx.BlockHeight(), 10, fraction) @@ -216,7 +226,7 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) { // read updated state validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) - newPool := keeper.GetPool(ctx) + newBondedPool := keeper.GetBondedPool(ctx) // end block updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -226,7 +236,8 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) { // power decreased require.Equal(t, int64(5), validator.GetConsensusPower()) // pool bonded shares decreased - require.Equal(t, sdk.TokensFromConsensusPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens)) + diffTokens := oldBondedPool.GetCoins().Sub(newBondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, sdk.TokensFromConsensusPower(5), diffTokens) } // tests Slash at a previous height with an unbonding delegation @@ -244,7 +255,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // slash validator for the first time ctx = ctx.WithBlockHeight(12) - oldPool := keeper.GetPool(ctx) + oldBondedPool := keeper.GetBondedPool(ctx) validator, found := keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) keeper.Slash(ctx, consAddr, 10, 10, fraction) @@ -260,9 +271,10 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // balance decreased require.Equal(t, sdk.TokensFromConsensusPower(2), ubd.Entries[0].Balance) // read updated pool - newPool := keeper.GetPool(ctx) + newBondedPool := keeper.GetBondedPool(ctx) // bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(3), oldPool.BondedTokens.Sub(newPool.BondedTokens)) + diffTokens := oldBondedPool.GetCoins().Sub(newBondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, sdk.TokensFromConsensusPower(3), diffTokens) // read updated validator validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) @@ -281,9 +293,10 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // balance decreased again require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance) // read updated pool - newPool = keeper.GetPool(ctx) + newBondedPool = keeper.GetBondedPool(ctx) // bonded tokens burned again - require.Equal(t, sdk.TokensFromConsensusPower(6), oldPool.BondedTokens.Sub(newPool.BondedTokens)) + diffTokens = oldBondedPool.GetCoins().Sub(newBondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, sdk.TokensFromConsensusPower(6), diffTokens) // read updated validator validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) @@ -302,9 +315,10 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // balance unchanged require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance) // read updated pool - newPool = keeper.GetPool(ctx) + newBondedPool = keeper.GetBondedPool(ctx) // bonded tokens burned again - require.Equal(t, sdk.TokensFromConsensusPower(9), oldPool.BondedTokens.Sub(newPool.BondedTokens)) + diffTokens = oldBondedPool.GetCoins().Sub(newBondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, sdk.TokensFromConsensusPower(9), diffTokens) // read updated validator validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) @@ -323,9 +337,10 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // balance unchanged require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance) // read updated pool - newPool = keeper.GetPool(ctx) + newBondedPool = keeper.GetBondedPool(ctx) // just 1 bonded token burned again since that's all the validator now has - require.Equal(t, sdk.TokensFromConsensusPower(10), oldPool.BondedTokens.Sub(newPool.BondedTokens)) + diffTokens = oldBondedPool.GetCoins().Sub(newBondedPool.GetCoins()).AmountOf(keeper.BondDenom(ctx)) + require.Equal(t, sdk.TokensFromConsensusPower(10), diffTokens) // apply TM updates keeper.ApplyAndReturnValidatorSetUpdates(ctx) // read updated validator @@ -340,6 +355,7 @@ func TestSlashWithRedelegation(t *testing.T) { ctx, keeper, _ := setupHelper(t, 10) consAddr := sdk.ConsAddress(PKs[0].Address()) fraction := sdk.NewDecWithPrec(5, 1) + bondDenom := keeper.BondDenom(ctx) // set a redelegation rdTokens := sdk.TokensFromConsensusPower(6) @@ -352,25 +368,35 @@ func TestSlashWithRedelegation(t *testing.T) { keeper.SetDelegation(ctx, del) // update bonded tokens - pool := keeper.GetPool(ctx) - pool.BondedTokens = pool.BondedTokens.Add(rdTokens) - keeper.SetPool(ctx, pool) + bondedPool := keeper.GetBondedPool(ctx) + notBondedPool := keeper.GetNotBondedPool(ctx) + rdCoins := sdk.NewCoins(sdk.NewCoin(bondDenom, rdTokens.MulRaw(2))) + err := bondedPool.SetCoins(bondedPool.GetCoins().Add(rdCoins)) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + + oldBonded := bondedPool.GetCoins().AmountOf(bondDenom) + oldNotBonded := notBondedPool.GetCoins().AmountOf(bondDenom) // slash validator ctx = ctx.WithBlockHeight(12) - oldPool := keeper.GetPool(ctx) validator, found := keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) - keeper.Slash(ctx, consAddr, 10, 10, fraction) + + require.NotPanics(t, func() { keeper.Slash(ctx, consAddr, 10, 10, fraction) }) + burnAmount := sdk.TokensFromConsensusPower(10).ToDec().Mul(fraction).TruncateInt() + + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + // burn bonded tokens from only from delegations + require.True(sdk.IntEq(t, oldBonded.Sub(burnAmount), bondedPool.GetCoins().AmountOf(bondDenom))) + require.True(sdk.IntEq(t, oldNotBonded, notBondedPool.GetCoins().AmountOf(bondDenom))) + oldBonded = bondedPool.GetCoins().AmountOf(bondDenom) // read updating redelegation rd, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1]) require.True(t, found) require.Len(t, rd.Entries, 1) - // read updated pool - newPool := keeper.GetPool(ctx) - // bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens)) // read updated validator validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) @@ -381,19 +407,24 @@ func TestSlashWithRedelegation(t *testing.T) { require.Equal(t, int64(8), validator.GetConsensusPower()) // slash the validator again - ctx = ctx.WithBlockHeight(12) validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) + require.NotPanics(t, func() { keeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) + burnAmount = sdk.TokensFromConsensusPower(7) + + // read updated pool + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + // seven bonded tokens burned + require.True(sdk.IntEq(t, oldBonded.Sub(burnAmount), bondedPool.GetCoins().AmountOf(bondDenom))) + require.True(sdk.IntEq(t, oldNotBonded, notBondedPool.GetCoins().AmountOf(bondDenom))) + oldBonded = bondedPool.GetCoins().AmountOf(bondDenom) // read updating redelegation rd, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1]) require.True(t, found) require.Len(t, rd.Entries, 1) - // read updated pool - newPool = keeper.GetPool(ctx) - // seven bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(12), oldPool.BondedTokens.Sub(newPool.BondedTokens)) // read updated validator validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) @@ -404,16 +435,23 @@ func TestSlashWithRedelegation(t *testing.T) { ctx = ctx.WithBlockHeight(12) validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr) require.True(t, found) - keeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) + + require.NotPanics(t, func() { keeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) + + burnAmount = sdk.TokensFromConsensusPower(10).ToDec().Mul(sdk.OneDec()).TruncateInt() + burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt()) + + // read updated pool + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, oldBonded.Sub(burnAmount), bondedPool.GetCoins().AmountOf(bondDenom))) + require.True(sdk.IntEq(t, oldNotBonded, notBondedPool.GetCoins().AmountOf(bondDenom))) + oldBonded = bondedPool.GetCoins().AmountOf(bondDenom) // read updating redelegation rd, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1]) require.True(t, found) require.Len(t, rd.Entries, 1) - // read updated pool - newPool = keeper.GetPool(ctx) - // four more bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(16), oldPool.BondedTokens.Sub(newPool.BondedTokens)) // apply TM updates keeper.ApplyAndReturnValidatorSetUpdates(ctx) // read updated validator @@ -427,16 +465,19 @@ func TestSlashWithRedelegation(t *testing.T) { // validator still in unbonding period validator, _ = keeper.GetValidatorByConsAddr(ctx, consAddr) require.Equal(t, validator.GetStatus(), sdk.Unbonding) - keeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) + + require.NotPanics(t, func() { keeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) + + // read updated pool + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, oldBonded, bondedPool.GetCoins().AmountOf(bondDenom))) + require.True(sdk.IntEq(t, oldNotBonded, notBondedPool.GetCoins().AmountOf(bondDenom))) // read updating redelegation rd, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1]) require.True(t, found) require.Len(t, rd.Entries, 1) - // read updated pool - newPool = keeper.GetPool(ctx) - // no more bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(16), oldPool.BondedTokens.Sub(newPool.BondedTokens)) // read updated validator // power still zero, still in unbonding period validator, _ = keeper.GetValidatorByConsAddr(ctx, consAddr) @@ -447,6 +488,7 @@ func TestSlashWithRedelegation(t *testing.T) { func TestSlashBoth(t *testing.T) { ctx, keeper, _ := setupHelper(t, 10) fraction := sdk.NewDecWithPrec(5, 1) + bondDenom := keeper.BondDenom(ctx) // set a redelegation with expiration timestamp beyond which the // redelegation shouldn't be slashed @@ -467,24 +509,41 @@ func TestSlashBoth(t *testing.T) { time.Unix(0, 0), ubdATokens) keeper.SetUnbondingDelegation(ctx, ubdA) + bondedCoins := sdk.NewCoins(sdk.NewCoin(bondDenom, rdATokens.MulRaw(2))) + notBondedCoins := sdk.NewCoins(sdk.NewCoin(bondDenom, ubdATokens)) + + // update bonded tokens + bondedPool := keeper.GetBondedPool(ctx) + notBondedPool := keeper.GetNotBondedPool(ctx) + require.NoError(t, bondedPool.SetCoins(bondedPool.GetCoins().Add(bondedCoins))) + require.NoError(t, bondedPool.SetCoins(notBondedPool.GetCoins().Add(notBondedCoins))) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + + oldBonded := bondedPool.GetCoins().AmountOf(bondDenom) + oldNotBonded := notBondedPool.GetCoins().AmountOf(bondDenom) + // slash validator ctx = ctx.WithBlockHeight(12) - oldPool := keeper.GetPool(ctx) validator, found := keeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0])) require.True(t, found) consAddr0 := sdk.ConsAddress(PKs[0].Address()) keeper.Slash(ctx, consAddr0, 10, 10, fraction) + burnedNotBondedAmount := fraction.MulInt(ubdATokens).TruncateInt() + burnedBondAmount := sdk.TokensFromConsensusPower(10).ToDec().Mul(fraction).TruncateInt() + burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount) + + // read updated pool + bondedPool = keeper.GetBondedPool(ctx) + notBondedPool = keeper.GetNotBondedPool(ctx) + require.True(sdk.IntEq(t, oldBonded.Sub(burnedBondAmount), bondedPool.GetCoins().AmountOf(bondDenom))) + require.True(sdk.IntEq(t, oldNotBonded.Sub(burnedNotBondedAmount), notBondedPool.GetCoins().AmountOf(bondDenom))) + // read updating redelegation rdA, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1]) require.True(t, found) require.Len(t, rdA.Entries, 1) - // read updated pool - newPool := keeper.GetPool(ctx) - // not-bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(2), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens)) - // bonded tokens burned - require.Equal(t, sdk.TokensFromConsensusPower(3), oldPool.BondedTokens.Sub(newPool.BondedTokens)) // read updated validator validator, found = keeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0])) require.True(t, found) diff --git a/x/staking/keeper/test_common.go b/x/staking/keeper/test_common.go index fd18d07c0..28a9944f6 100644 --- a/x/staking/keeper/test_common.go +++ b/x/staking/keeper/test_common.go @@ -23,6 +23,8 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank" "github.com/cosmos/cosmos-sdk/x/params" "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/cosmos/cosmos-sdk/x/supply" + "github.com/cosmos/cosmos-sdk/x/supply/exported" ) // dummy addresses used for testing @@ -67,7 +69,9 @@ func MakeTestCodec() *codec.Codec { // Register AppAccount cdc.RegisterInterface((*auth.Account)(nil), nil) - cdc.RegisterConcrete(&auth.BaseAccount{}, "test/staking/Account", nil) + cdc.RegisterConcrete(&auth.BaseAccount{}, "test/staking/BaseAccount", nil) + cdc.RegisterInterface((*exported.ModuleAccountI)(nil), nil) + cdc.RegisterConcrete(&supply.ModuleAccount{}, "test/staking/ModuleAccount", nil) codec.RegisterCrypto(cdc) return cdc @@ -76,15 +80,13 @@ func MakeTestCodec() *codec.Codec { // Hogpodge of all sorts of input required for testing. // `initPower` is converted to an amount of tokens. // If `initPower` is 0, no addrs get created. -func CreateTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context, auth.AccountKeeper, Keeper) { - - initCoins := sdk.TokensFromConsensusPower(initPower) - +func CreateTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context, auth.AccountKeeper, Keeper, types.SupplyKeeper) { keyStaking := sdk.NewKVStoreKey(types.StoreKey) tkeyStaking := sdk.NewTransientStoreKey(types.TStoreKey) keyAcc := sdk.NewKVStoreKey(auth.StoreKey) keyParams := sdk.NewKVStoreKey(params.StoreKey) tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey) + keySupply := sdk.NewKVStoreKey(supply.StoreKey) db := dbm.NewMemDB() ms := store.NewCommitMultiStore(db) @@ -93,6 +95,7 @@ func CreateTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) + ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db) err := ms.LoadLatestVersion() require.Nil(t, err) @@ -115,31 +118,45 @@ func CreateTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context auth.ProtoBaseAccount, // prototype ) - ck := bank.NewBaseKeeper( + bk := bank.NewBaseKeeper( accountKeeper, pk.Subspace(bank.DefaultParamspace), bank.DefaultCodespace, ) - keeper := NewKeeper(cdc, keyStaking, tkeyStaking, ck, pk.Subspace(DefaultParamspace), types.DefaultCodespace) - keeper.SetPool(ctx, types.InitialPool()) + supplyKeeper := supply.NewKeeper(cdc, keySupply, accountKeeper, bk, supply.DefaultCodespace, + []string{auth.FeeCollectorName}, []string{}, []string{types.NotBondedPoolName, types.BondedPoolName}) + + initTokens := sdk.TokensFromConsensusPower(initPower) + initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) + totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens.MulRaw(int64(len(Addrs))))) + + supplyKeeper.SetSupply(ctx, supply.NewSupply(totalSupply)) + + keeper := NewKeeper(cdc, keyStaking, tkeyStaking, supplyKeeper, pk.Subspace(DefaultParamspace), types.DefaultCodespace) keeper.SetParams(ctx, types.DefaultParams()) + // set module accounts + feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName, supply.Basic) + notBondedPool := supply.NewEmptyModuleAccount(types.NotBondedPoolName, supply.Burner) + bondPool := supply.NewEmptyModuleAccount(types.BondedPoolName, supply.Burner) + + err = notBondedPool.SetCoins(totalSupply) + require.NoError(t, err) + + supplyKeeper.SetModuleAccount(ctx, feeCollectorAcc) + supplyKeeper.SetModuleAccount(ctx, bondPool) + supplyKeeper.SetModuleAccount(ctx, notBondedPool) + // fill all the addresses with some coins, set the loose pool tokens simultaneously for _, addr := range Addrs { - pool := keeper.GetPool(ctx) - err := error(nil) - if !initCoins.IsZero() { - _, err = ck.AddCoins(ctx, addr, sdk.Coins{ - {keeper.BondDenom(ctx), initCoins}, - }) + _, err := bk.AddCoins(ctx, addr, initCoins) + if err != nil { + panic(err) } - require.Nil(t, err) - pool.NotBondedTokens = pool.NotBondedTokens.Add(initCoins) - keeper.SetPool(ctx, pool) } - return ctx, accountKeeper, keeper + return ctx, accountKeeper, keeper, supplyKeeper } func NewPubKey(pk string) (res crypto.PubKey) { @@ -222,23 +239,24 @@ func ValidatorByPowerIndexExists(ctx sdk.Context, keeper Keeper, power []byte) b // update validator for testing func TestingUpdateValidator(keeper Keeper, ctx sdk.Context, validator types.Validator, apply bool) types.Validator { keeper.SetValidator(ctx, validator) - { // Remove any existing power key for validator. - store := ctx.KVStore(keeper.storeKey) - iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsByPowerIndexKey) - defer iterator.Close() - deleted := false - for ; iterator.Valid(); iterator.Next() { - valAddr := types.ParseValidatorPowerRankKey(iterator.Key()) - if bytes.Equal(valAddr, validator.OperatorAddress) { - if deleted { - panic("found duplicate power index key") - } else { - deleted = true - } - store.Delete(iterator.Key()) + + // Remove any existing power key for validator. + store := ctx.KVStore(keeper.storeKey) + iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsByPowerIndexKey) + defer iterator.Close() + deleted := false + for ; iterator.Valid(); iterator.Next() { + valAddr := types.ParseValidatorPowerRankKey(iterator.Key()) + if bytes.Equal(valAddr, validator.OperatorAddress) { + if deleted { + panic("found duplicate power index key") + } else { + deleted = true } + store.Delete(iterator.Key()) } } + keeper.SetValidatorByPowerIndex(ctx, validator) if apply { keeper.ApplyAndReturnValidatorSetUpdates(ctx) diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go index 6ed450147..49d8e40be 100644 --- a/x/staking/keeper/val_state_change.go +++ b/x/staking/keeper/val_state_change.go @@ -28,6 +28,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab store := ctx.KVStore(k.storeKey) maxValidators := k.GetParams(ctx).MaxValidators totalPower := sdk.ZeroInt() + amtFromBondedToNotBonded, amtFromNotBondedToBonded := sdk.ZeroInt(), sdk.ZeroInt() // Retrieve the last validator set. // The persistent set is updated later in this function. @@ -39,6 +40,9 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab defer iterator.Close() for count := 0; iterator.Valid() && count < int(maxValidators); iterator.Next() { + // everything that is iterated in this loop is becoming or already a + // part of the bonded validator set + // fetch the validator valAddr := sdk.ValAddress(iterator.Value()) validator := k.mustGetValidator(ctx, valAddr) @@ -54,12 +58,14 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab } // apply the appropriate state change if necessary - switch validator.Status { - case sdk.Unbonded: + switch { + case validator.IsUnbonded(): validator = k.unbondedToBonded(ctx, validator) - case sdk.Unbonding: + amtFromNotBondedToBonded = amtFromNotBondedToBonded.Add(validator.GetTokens()) + case validator.IsUnbonding(): validator = k.unbondingToBonded(ctx, validator) - case sdk.Bonded: + amtFromNotBondedToBonded = amtFromNotBondedToBonded.Add(validator.GetTokens()) + case validator.IsBonded(): // no state change default: panic("unexpected validator status") @@ -100,15 +106,32 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab validator := k.mustGetValidator(ctx, sdk.ValAddress(valAddrBytes)) // bonded to unbonding - k.bondedToUnbonding(ctx, validator) + validator = k.bondedToUnbonding(ctx, validator) + amtFromBondedToNotBonded = amtFromBondedToNotBonded.Add(validator.GetTokens()) // delete from the bonded validator index - k.DeleteLastValidatorPower(ctx, sdk.ValAddress(valAddrBytes)) + k.DeleteLastValidatorPower(ctx, validator.GetOperator()) // update the validator set updates = append(updates, validator.ABCIValidatorUpdateZero()) } + // Update the pools based on the recent updates in the validator set: + // - The tokens from the non-bonded candidates that enter the new validator set need to be transferred + // to the Bonded pool. + // - The tokens from the bonded validators that are being kicked out from the validator set + // need to be transferred to the NotBonded pool. + switch { + // Compare and subtract the respective amounts to only perform one transfer. + // This is done in order to avoid doing multiple updates inside each iterator/loop. + case amtFromNotBondedToBonded.GT(amtFromBondedToNotBonded): + k.notBondedTokensToBonded(ctx, amtFromNotBondedToBonded.Sub(amtFromBondedToNotBonded)) + case amtFromNotBondedToBonded.LT(amtFromBondedToNotBonded): + k.bondedTokensToNotBonded(ctx, amtFromBondedToNotBonded.Sub(amtFromNotBondedToBonded)) + default: + // equal amounts of tokens; no update required + } + // set total power on lookup index if there are any updates if len(updates) > 0 { k.SetLastTotalPower(ctx, totalPower) @@ -177,9 +200,7 @@ func (k Keeper) bondValidator(ctx sdk.Context, validator types.Validator) types. k.DeleteValidatorByPowerIndex(ctx, validator) // set the status - pool := k.GetPool(ctx) - validator, pool = validator.UpdateStatus(pool, sdk.Bonded) - k.SetPool(ctx, pool) + validator = validator.UpdateStatus(sdk.Bonded) // save the now bonded validator record to the two referenced stores k.SetValidator(ctx, validator) @@ -208,9 +229,7 @@ func (k Keeper) beginUnbondingValidator(ctx sdk.Context, validator types.Validat } // set the status - pool := k.GetPool(ctx) - validator, pool = validator.UpdateStatus(pool, sdk.Unbonding) - k.SetPool(ctx, pool) + validator = validator.UpdateStatus(sdk.Unbonding) // set the unbonding completion time and completion height appropriately validator.UnbondingCompletionTime = ctx.BlockHeader().Time.Add(params.UnbondingTime) @@ -231,9 +250,7 @@ func (k Keeper) beginUnbondingValidator(ctx sdk.Context, validator types.Validat // perform all the store operations for when a validator status becomes unbonded func (k Keeper) completeUnbondingValidator(ctx sdk.Context, validator types.Validator) types.Validator { - pool := k.GetPool(ctx) - validator, pool = validator.UpdateStatus(pool, sdk.Unbonded) - k.SetPool(ctx, pool) + validator = validator.UpdateStatus(sdk.Unbonded) k.SetValidator(ctx, validator) return validator } diff --git a/x/staking/keeper/validator.go b/x/staking/keeper/validator.go index 650669499..5f26071d3 100644 --- a/x/staking/keeper/validator.go +++ b/x/staking/keeper/validator.go @@ -125,10 +125,8 @@ func (k Keeper) AddValidatorTokensAndShares(ctx sdk.Context, validator types.Val tokensToAdd sdk.Int) (valOut types.Validator, addedShares sdk.Dec) { k.DeleteValidatorByPowerIndex(ctx, validator) - pool := k.GetPool(ctx) - validator, pool, addedShares = validator.AddTokensFromDel(pool, tokensToAdd) + validator, addedShares = validator.AddTokensFromDel(tokensToAdd) k.SetValidator(ctx, validator) - k.SetPool(ctx, pool) k.SetValidatorByPowerIndex(ctx, validator) return validator, addedShares } @@ -138,10 +136,8 @@ func (k Keeper) RemoveValidatorTokensAndShares(ctx sdk.Context, validator types. sharesToRemove sdk.Dec) (valOut types.Validator, removedTokens sdk.Int) { k.DeleteValidatorByPowerIndex(ctx, validator) - pool := k.GetPool(ctx) - validator, pool, removedTokens = validator.RemoveDelShares(pool, sharesToRemove) + validator, removedTokens = validator.RemoveDelShares(sharesToRemove) k.SetValidator(ctx, validator) - k.SetPool(ctx, pool) k.SetValidatorByPowerIndex(ctx, validator) return validator, removedTokens } @@ -151,10 +147,8 @@ func (k Keeper) RemoveValidatorTokens(ctx sdk.Context, validator types.Validator, tokensToRemove sdk.Int) types.Validator { k.DeleteValidatorByPowerIndex(ctx, validator) - pool := k.GetPool(ctx) - validator, pool = validator.RemoveTokens(pool, tokensToRemove) + validator = validator.RemoveTokens(tokensToRemove) k.SetValidator(ctx, validator) - k.SetPool(ctx, pool) k.SetValidatorByPowerIndex(ctx, validator) return validator } @@ -441,9 +435,7 @@ func (k Keeper) UnbondAllMatureValidatorQueue(ctx sdk.Context) { if !val.IsUnbonding() { panic("unexpected validator in unbonding queue; status was not unbonding") } - - k.unbondingToUnbonded(ctx, val) - + val = k.unbondingToUnbonded(ctx, val) if val.GetDelegatorShares().IsZero() { k.RemoveValidator(ctx, val.OperatorAddress) } diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go index 2f1a51369..a5d909a8a 100644 --- a/x/staking/keeper/validator_test.go +++ b/x/staking/keeper/validator_test.go @@ -17,8 +17,7 @@ import ( //_______________________________________________________ func TestSetValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 10) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 10) valPubKey := PKs[0] valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) @@ -26,11 +25,10 @@ func TestSetValidator(t *testing.T) { // test how the validator is set from a purely unbonbed pool validator := types.NewValidator(valAddr, valPubKey, types.Description{}) - validator, pool, _ = validator.AddTokensFromDel(pool, valTokens) + validator, _ = validator.AddTokensFromDel(valTokens) require.Equal(t, sdk.Unbonded, validator.Status) assert.Equal(t, valTokens, validator.Tokens) assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt()) - keeper.SetPool(ctx, pool) keeper.SetValidator(ctx, validator) keeper.SetValidatorByPowerIndex(ctx, validator) @@ -72,40 +70,38 @@ func TestSetValidator(t *testing.T) { } func TestUpdateValidatorByPowerIndex(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) - // create a random pool - pool.NotBondedTokens = sdk.TokensFromConsensusPower(10000) - pool.BondedTokens = sdk.TokensFromConsensusPower(1234) - keeper.SetPool(ctx, pool) + bondedPool := keeper.GetBondedPool(ctx) + notBondedPool := keeper.GetNotBondedPool(ctx) + bondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))) + notBondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) // add a validator validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) - validator, pool, delSharesCreated := validator.AddTokensFromDel(pool, sdk.TokensFromConsensusPower(100)) + validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100)) require.Equal(t, sdk.Unbonded, validator.Status) require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens) - keeper.SetPool(ctx, pool) TestingUpdateValidator(keeper, ctx, validator, true) validator, found := keeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens, "\nvalidator %v\npool %v", validator, pool) + require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens) - pool = keeper.GetPool(ctx) power := types.GetValidatorsByPowerIndexKey(validator) require.True(t, validatorByPowerIndexExists(keeper, ctx, power)) // burn half the delegator shares keeper.DeleteValidatorByPowerIndex(ctx, validator) - validator, pool, burned := validator.RemoveDelShares(pool, delSharesCreated.Quo(sdk.NewDec(2))) + validator, burned := validator.RemoveDelShares(delSharesCreated.Quo(sdk.NewDec(2))) require.Equal(t, sdk.TokensFromConsensusPower(50), burned) - keeper.SetPool(ctx, pool) // update the pool TestingUpdateValidator(keeper, ctx, validator, true) // update the validator, possibly kicking it out require.False(t, validatorByPowerIndexExists(keeper, ctx, power)) - pool = keeper.GetPool(ctx) validator, found = keeper.GetValidator(ctx, addrVals[0]) require.True(t, found) + power = types.GetValidatorsByPowerIndexKey(validator) require.True(t, validatorByPowerIndexExists(keeper, ctx, power)) } @@ -115,8 +111,9 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { maxVals := 5 // create context, keeper, and pool for tests - ctx, _, keeper := CreateTestInput(t, false, 0) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 0) + bondedPool := keeper.GetBondedPool(ctx) + notBondedPool := keeper.GetNotBondedPool(ctx) // create keeper parameters params := keeper.GetParams(ctx) @@ -124,18 +121,18 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { keeper.SetParams(ctx, params) // create a random pool - pool.NotBondedTokens = sdk.TokensFromConsensusPower(10000) - pool.BondedTokens = sdk.TokensFromConsensusPower(1234) - keeper.SetPool(ctx, pool) + bondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))) + notBondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) validators := make([]types.Validator, numVals) for i := 0; i < len(validators); i++ { moniker := fmt.Sprintf("val#%d", int64(i)) val := types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker}) delTokens := sdk.TokensFromConsensusPower(int64((i + 1) * 10)) - val, pool, _ = val.AddTokensFromDel(pool, delTokens) + val, _ = val.AddTokensFromDel(delTokens) - keeper.SetPool(ctx, pool) val = TestingUpdateValidator(keeper, ctx, val, true) validators[i] = val } @@ -146,8 +143,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { // validator and next in line cliff validator keeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal) shares := sdk.TokensFromConsensusPower(21) - nextCliffVal, pool, _ = nextCliffVal.RemoveDelShares(pool, shares.ToDec()) - keeper.SetPool(ctx, pool) + nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec()) nextCliffVal = TestingUpdateValidator(keeper, ctx, nextCliffVal, true) expectedValStatus := map[int]sdk.BondStatus{ @@ -169,19 +165,23 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { func TestSlashToZeroPowerRemoved(t *testing.T) { // initialize setup - ctx, _, keeper := CreateTestInput(t, false, 100) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 100) // add a validator validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) valTokens := sdk.TokensFromConsensusPower(100) - validator, pool, _ = validator.AddTokensFromDel(pool, valTokens) + + bondedPool := keeper.GetBondedPool(ctx) + err := bondedPool.SetCoins(sdk.NewCoins(sdk.NewCoin(keeper.BondDenom(ctx), valTokens))) + require.NoError(t, err) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + + validator, _ = validator.AddTokensFromDel(valTokens) require.Equal(t, sdk.Unbonded, validator.Status) require.Equal(t, valTokens, validator.Tokens) - keeper.SetPool(ctx, pool) keeper.SetValidatorByConsAddr(ctx, validator) validator = TestingUpdateValidator(keeper, ctx, validator, true) - require.Equal(t, valTokens, validator.Tokens, "\nvalidator %v\npool %v", validator, pool) + require.Equal(t, valTokens, validator.Tokens, "\nvalidator %v\npool %v", validator, valTokens) // slash the validator by 100% consAddr0 := sdk.ConsAddress(PKs[0].Address()) @@ -195,8 +195,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) { // This function tests UpdateValidator, GetValidator, GetLastValidators, RemoveValidator func TestValidatorBasics(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) //construct the validators var validators [3]types.Validator @@ -206,8 +205,8 @@ func TestValidatorBasics(t *testing.T) { validators[i].Status = sdk.Unbonded validators[i].Tokens = sdk.ZeroInt() tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + + validators[i], _ = validators[i].AddTokensFromDel(tokens) } assert.Equal(t, sdk.TokensFromConsensusPower(9), validators[0].Tokens) assert.Equal(t, sdk.TokensFromConsensusPower(8), validators[1].Tokens) @@ -222,9 +221,6 @@ func TestValidatorBasics(t *testing.T) { resVals = keeper.GetValidators(ctx, 2) require.Zero(t, len(resVals)) - pool = keeper.GetPool(ctx) - assert.True(sdk.IntEq(t, sdk.ZeroInt(), pool.BondedTokens)) - // set and retrieve a record validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true) keeper.SetValidatorByConsAddr(ctx, validators[0]) @@ -246,9 +242,6 @@ func TestValidatorBasics(t *testing.T) { assert.Equal(t, sdk.Bonded, validators[0].Status) assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9), validators[0].BondedTokens())) - pool = keeper.GetPool(ctx) - assert.True(sdk.IntEq(t, pool.BondedTokens, validators[0].BondedTokens())) - // modify a records, save, and retrieve validators[0].Status = sdk.Bonded validators[0].Tokens = sdk.TokensFromConsensusPower(10) @@ -301,7 +294,7 @@ func TestValidatorBasics(t *testing.T) { // test how the validators are sorted, tests GetBondedValidatorsByPower func GetValidatorSortingUnmixed(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) // initialize some validators into the state amts := []int64{0, 100, 1, 400, 200} @@ -376,7 +369,7 @@ func GetValidatorSortingUnmixed(t *testing.T) { } func GetValidatorSortingMixed(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) // now 2 max resValidators params := keeper.GetParams(ctx) @@ -408,7 +401,7 @@ func GetValidatorSortingMixed(t *testing.T) { for i := range amts { TestingUpdateValidator(keeper, ctx, validators[i], true) } - val0, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[0])) + val0, found := keeper.GetValidator(ctx, sdk.ValAddress(sdk.ValAddress(PKs[0].Address().Bytes()))) require.True(t, found) val1, found := keeper.GetValidator(ctx, sdk.ValAddress(Addrs[1])) require.True(t, found) @@ -441,10 +434,9 @@ func GetValidatorSortingMixed(t *testing.T) { // TODO separate out into multiple tests func TestGetValidatorsEdgeCases(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) - var found bool + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) - // now 2 max resValidators + // set max validators to 2 params := keeper.GetParams(ctx) nMax := uint16(2) params.MaxValidators = nMax @@ -454,47 +446,61 @@ func TestGetValidatorsEdgeCases(t *testing.T) { powers := []int64{0, 100, 400, 400} var validators [4]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) moniker := fmt.Sprintf("val#%d", int64(i)) validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + notBondedPool := keeper.GetNotBondedPool(ctx) + require.NoError(t, notBondedPool.SetCoins(notBondedPool.GetCoins().Add(sdk.NewCoins(sdk.NewCoin(params.BondDenom, tokens))))) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) validators[i] = TestingUpdateValidator(keeper, ctx, validators[i], true) } - for i := range powers { - validators[i], found = keeper.GetValidator(ctx, validators[i].OperatorAddress) - require.True(t, found) - } + // ensure that the first two bonded validators are the largest validators resValidators := keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, nMax, uint16(len(resValidators))) assert.True(ValEq(t, validators[2], resValidators[0])) assert.True(ValEq(t, validators[3], resValidators[1])) - pool := keeper.GetPool(ctx) + // delegate 500 tokens to validator 0 keeper.DeleteValidatorByPowerIndex(ctx, validators[0]) delTokens := sdk.TokensFromConsensusPower(500) - validators[0], pool, _ = validators[0].AddTokensFromDel(pool, delTokens) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].AddTokensFromDel(delTokens) + notBondedPool := keeper.GetNotBondedPool(ctx) + newTokens := sdk.NewCoins(sdk.NewCoin(params.BondDenom, delTokens)) + require.NoError(t, notBondedPool.SetCoins(notBondedPool.GetCoins().Add(newTokens))) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + + // test that the two largest validators are + // a) validator 0 with 500 tokens + // b) validator 2 with 400 tokens (delegated before validator 3) validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true) resValidators = keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, nMax, uint16(len(resValidators))) assert.True(ValEq(t, validators[0], resValidators[0])) assert.True(ValEq(t, validators[2], resValidators[1])) - // A validator which leaves the gotValidator set due to a decrease in voting power, + // A validator which leaves the bonded validator set due to a decrease in voting power, // then increases to the original voting power, does not get its spot back in the // case of a tie. + // + // Order of operations for this test: + // - validator 3 enter validator set with 1 new token + // - validator 3 removed validator set by removing 201 tokens (validator 2 enters) + // - validator 3 adds 200 tokens (equal to validator 2 now) and does not get its spot back // validator 3 enters bonded validator set ctx = ctx.WithBlockHeight(40) - validators[3], found = keeper.GetValidator(ctx, validators[3].OperatorAddress) - require.True(t, found) + validators[3] = keeper.mustGetValidator(ctx, validators[3].OperatorAddress) keeper.DeleteValidatorByPowerIndex(ctx, validators[3]) - validators[3], pool, _ = validators[3].AddTokensFromDel(pool, sdk.TokensFromConsensusPower(1)) - keeper.SetPool(ctx, pool) + validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1)) + + notBondedPool = keeper.GetNotBondedPool(ctx) + newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1))) + require.NoError(t, notBondedPool.SetCoins(notBondedPool.GetCoins().Add(newTokens))) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + validators[3] = TestingUpdateValidator(keeper, ctx, validators[3], true) resValidators = keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, nMax, uint16(len(resValidators))) @@ -503,18 +509,27 @@ func TestGetValidatorsEdgeCases(t *testing.T) { // validator 3 kicked out temporarily keeper.DeleteValidatorByPowerIndex(ctx, validators[3]) - validators[3], pool, _ = validators[3].RemoveDelShares(pool, sdk.NewDec(201)) - keeper.SetPool(ctx, pool) + rmTokens := validators[3].TokensFromShares(sdk.NewDec(201)).TruncateInt() + validators[3], _ = validators[3].RemoveDelShares(sdk.NewDec(201)) + + bondedPool := keeper.GetBondedPool(ctx) + require.NoError(t, bondedPool.SetCoins(bondedPool.GetCoins().Add(sdk.NewCoins(sdk.NewCoin(params.BondDenom, rmTokens))))) + keeper.supplyKeeper.SetModuleAccount(ctx, bondedPool) + validators[3] = TestingUpdateValidator(keeper, ctx, validators[3], true) resValidators = keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, nMax, uint16(len(resValidators))) assert.True(ValEq(t, validators[0], resValidators[0])) assert.True(ValEq(t, validators[2], resValidators[1])) - // validator 4 does not get spot back + // validator 3 does not get spot back keeper.DeleteValidatorByPowerIndex(ctx, validators[3]) - validators[3], pool, _ = validators[3].AddTokensFromDel(pool, sdk.NewInt(200)) - keeper.SetPool(ctx, pool) + validators[3], _ = validators[3].AddTokensFromDel(sdk.NewInt(200)) + + notBondedPool = keeper.GetNotBondedPool(ctx) + require.NoError(t, notBondedPool.SetCoins(notBondedPool.GetCoins().Add(sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.NewInt(200)))))) + keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool) + validators[3] = TestingUpdateValidator(keeper, ctx, validators[3], true) resValidators = keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, nMax, uint16(len(resValidators))) @@ -525,8 +540,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) { } func TestValidatorBondHeight(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) - pool := keeper.GetPool(ctx) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) // now 2 max resValidators params := keeper.GetParams(ctx) @@ -535,17 +549,16 @@ func TestValidatorBondHeight(t *testing.T) { // initialize some validators into the state var validators [3]types.Validator - validators[0] = types.NewValidator(sdk.ValAddress(Addrs[0]), PKs[0], types.Description{}) + validators[0] = types.NewValidator(sdk.ValAddress(sdk.ValAddress(PKs[0].Address().Bytes())), PKs[0], types.Description{}) validators[1] = types.NewValidator(sdk.ValAddress(Addrs[1]), PKs[1], types.Description{}) validators[2] = types.NewValidator(sdk.ValAddress(Addrs[2]), PKs[2], types.Description{}) tokens0 := sdk.TokensFromConsensusPower(200) tokens1 := sdk.TokensFromConsensusPower(100) tokens2 := sdk.TokensFromConsensusPower(100) - validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens0) - validators[1], pool, _ = validators[1].AddTokensFromDel(pool, tokens1) - validators[2], pool, _ = validators[2].AddTokensFromDel(pool, tokens2) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].AddTokensFromDel(tokens0) + validators[1], _ = validators[1].AddTokensFromDel(tokens1) + validators[2], _ = validators[2].AddTokensFromDel(tokens2) validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true) @@ -555,8 +568,6 @@ func TestValidatorBondHeight(t *testing.T) { validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], true) validators[2] = TestingUpdateValidator(keeper, ctx, validators[2], true) - pool = keeper.GetPool(ctx) - resValidators := keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, uint16(len(resValidators)), params.MaxValidators) @@ -565,9 +576,8 @@ func TestValidatorBondHeight(t *testing.T) { keeper.DeleteValidatorByPowerIndex(ctx, validators[1]) keeper.DeleteValidatorByPowerIndex(ctx, validators[2]) delTokens := sdk.TokensFromConsensusPower(50) - validators[1], pool, _ = validators[1].AddTokensFromDel(pool, delTokens) - validators[2], pool, _ = validators[2].AddTokensFromDel(pool, delTokens) - keeper.SetPool(ctx, pool) + validators[1], _ = validators[1].AddTokensFromDel(delTokens) + validators[2], _ = validators[2].AddTokensFromDel(delTokens) validators[2] = TestingUpdateValidator(keeper, ctx, validators[2], true) resValidators = keeper.GetBondedValidatorsByPower(ctx) require.Equal(t, params.MaxValidators, uint16(len(resValidators))) @@ -577,7 +587,7 @@ func TestValidatorBondHeight(t *testing.T) { } func TestFullValidatorSetPowerChange(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) params := keeper.GetParams(ctx) max := 2 params.MaxValidators = uint16(2) @@ -587,11 +597,9 @@ func TestFullValidatorSetPowerChange(t *testing.T) { powers := []int64{0, 100, 400, 400, 200} var validators [5]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) TestingUpdateValidator(keeper, ctx, validators[i], true) } for i := range powers { @@ -610,10 +618,9 @@ func TestFullValidatorSetPowerChange(t *testing.T) { assert.True(ValEq(t, validators[3], resValidators[1])) // test a swap in voting power - pool := keeper.GetPool(ctx) + tokens := sdk.TokensFromConsensusPower(600) - validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].AddTokensFromDel(tokens) validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true) resValidators = keeper.GetBondedValidatorsByPower(ctx) assert.Equal(t, max, len(resValidators)) @@ -622,20 +629,17 @@ func TestFullValidatorSetPowerChange(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) powers := []int64{10, 20} var validators [2]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) - valPubKey := PKs[i+1] valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) } // test from nothing to something @@ -655,17 +659,16 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) powers := []int64{10, 20} var validators [2]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + } validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -679,17 +682,17 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) powers := []int64{10, 20} var validators [2]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) + validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + } validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -708,17 +711,17 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) powers := []int64{10, 20} var validators [2]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) + validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + } validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -726,12 +729,10 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) { // test multiple value change // tendermintUpdate set: {c1, c3} -> {c1', c3'} - pool := keeper.GetPool(ctx) delTokens1 := sdk.TokensFromConsensusPower(190) delTokens2 := sdk.TokensFromConsensusPower(80) - validators[0], pool, _ = validators[0].AddTokensFromDel(pool, delTokens1) - validators[1], pool, _ = validators[1].AddTokensFromDel(pool, delTokens2) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].AddTokensFromDel(delTokens1) + validators[1], _ = validators[1].AddTokensFromDel(delTokens2) validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -742,17 +743,17 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) powers := []int64{10, 20, 5, 15, 25} var validators [5]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) + validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + } validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) @@ -788,7 +789,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) params := types.DefaultParams() params.MaxValidators = 2 keeper.SetParams(ctx, params) @@ -796,12 +797,12 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { powers := []int64{10, 20, 5} var validators [5]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) + validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + } validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -817,10 +818,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { // tendermintUpdate set: {} -> {c0, c4} require.Equal(t, 0, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx))) - pool := keeper.GetPool(ctx) tokens := sdk.TokensFromConsensusPower(10) - validators[2], pool, _ = validators[2].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[2], _ = validators[2].AddTokensFromDel(tokens) keeper.SetValidator(ctx, validators[2]) keeper.SetValidatorByPowerIndex(ctx, validators[2]) updates = keeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -831,17 +830,17 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) powers := []int64{100, 100} var validators [2]types.Validator for i, power := range powers { - pool := keeper.GetPool(ctx) + validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) + } validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -853,12 +852,10 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) { // test multiple value change // tendermintUpdate set: {c1, c3} -> {c1', c3'} - pool := keeper.GetPool(ctx) delTokens1 := sdk.TokensFromConsensusPower(20) delTokens2 := sdk.TokensFromConsensusPower(30) - validators[0], pool, _ = validators[0].RemoveDelShares(pool, delTokens1.ToDec()) - validators[1], pool, _ = validators[1].RemoveDelShares(pool, delTokens2.ToDec()) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].RemoveDelShares(delTokens1.ToDec()) + validators[1], _ = validators[1].RemoveDelShares(delTokens2.ToDec()) validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -874,7 +871,7 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) params := keeper.GetParams(ctx) params.MaxValidators = uint16(3) @@ -885,15 +882,14 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { // initialize some validators into the state for i, power := range powers { - pool := keeper.GetPool(ctx) + valPubKey := PKs[i+1] valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) + validators[i], _ = validators[i].AddTokensFromDel(tokens) - keeper.SetPool(ctx, pool) keeper.SetValidator(ctx, validators[i]) keeper.SetValidatorByPowerIndex(ctx, validators[i]) } @@ -910,30 +906,27 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { // update initial validator set for i, power := range powers { - pool := keeper.GetPool(ctx) + keeper.DeleteValidatorByPowerIndex(ctx, validators[i]) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) + validators[i], _ = validators[i].AddTokensFromDel(tokens) - keeper.SetPool(ctx, pool) keeper.SetValidator(ctx, validators[i]) keeper.SetValidatorByPowerIndex(ctx, validators[i]) } // add a new validator that goes from zero power, to non-zero power, back to // zero power - pool := keeper.GetPool(ctx) valPubKey := PKs[len(validators)+1] valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) amt := sdk.NewInt(100) validator := types.NewValidator(valAddr, valPubKey, types.Description{}) - validator, pool, _ = validator.AddTokensFromDel(pool, amt) + validator, _ = validator.AddTokensFromDel(amt) - keeper.SetPool(ctx, pool) keeper.SetValidator(ctx, validator) - validator, pool, _ = validator.RemoveDelShares(pool, amt.ToDec()) + validator, _ = validator.RemoveDelShares(amt.ToDec()) keeper.SetValidator(ctx, validator) keeper.SetValidatorByPowerIndex(ctx, validator) @@ -943,10 +936,9 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { validator = types.NewValidator(valAddr, valPubKey, types.Description{}) tokens := sdk.TokensFromConsensusPower(500) - validator, pool, _ = validator.AddTokensFromDel(pool, tokens) + validator, _ = validator.AddTokensFromDel(tokens) keeper.SetValidator(ctx, validator) keeper.SetValidatorByPowerIndex(ctx, validator) - keeper.SetPool(ctx, pool) // verify initial Tendermint updates are correct updates = keeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -960,7 +952,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) { } func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) params := keeper.GetParams(ctx) params.MaxValidators = uint16(2) @@ -971,15 +963,13 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { // initialize some validators into the state for i, power := range powers { - pool := keeper.GetPool(ctx) moniker := fmt.Sprintf("%d", i) valPubKey := PKs[i+1] valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{Moniker: moniker}) tokens := sdk.TokensFromConsensusPower(power) - validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[i], _ = validators[i].AddTokensFromDel(tokens) keeper.SetValidator(ctx, validators[i]) keeper.SetValidatorByPowerIndex(ctx, validators[i]) } @@ -996,7 +986,6 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { // delegate to validator with lowest power but not enough to bond ctx = ctx.WithBlockHeight(1) - pool := keeper.GetPool(ctx) var found bool validators[0], found = keeper.GetValidator(ctx, validators[0].OperatorAddress) @@ -1004,8 +993,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { keeper.DeleteValidatorByPowerIndex(ctx, validators[0]) tokens := sdk.TokensFromConsensusPower(1) - validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].AddTokensFromDel(tokens) keeper.SetValidator(ctx, validators[0]) keeper.SetValidatorByPowerIndex(ctx, validators[0]) @@ -1015,14 +1003,12 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { // create a series of events that will bond and unbond the validator with // lowest power in a single block context (height) ctx = ctx.WithBlockHeight(2) - pool = keeper.GetPool(ctx) validators[1], found = keeper.GetValidator(ctx, validators[1].OperatorAddress) require.True(t, found) keeper.DeleteValidatorByPowerIndex(ctx, validators[0]) - validators[0], pool, _ = validators[0].RemoveDelShares(pool, validators[0].DelegatorShares) - keeper.SetPool(ctx, pool) + validators[0], _ = validators[0].RemoveDelShares(validators[0].DelegatorShares) keeper.SetValidator(ctx, validators[0]) keeper.SetValidatorByPowerIndex(ctx, validators[0]) updates = keeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -1030,8 +1016,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { keeper.DeleteValidatorByPowerIndex(ctx, validators[1]) tokens = sdk.TokensFromConsensusPower(250) - validators[1], pool, _ = validators[1].AddTokensFromDel(pool, tokens) - keeper.SetPool(ctx, pool) + validators[1], _ = validators[1].AddTokensFromDel(tokens) keeper.SetValidator(ctx, validators[1]) keeper.SetValidatorByPowerIndex(ctx, validators[1]) @@ -1044,7 +1029,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) { } func TestUpdateValidatorCommission(t *testing.T) { - ctx, _, keeper := CreateTestInput(t, false, 1000) + ctx, _, keeper, _ := CreateTestInput(t, false, 1000) ctx = ctx.WithBlockHeader(abci.Header{Time: time.Now().UTC()}) commission1 := types.NewCommissionWithTime( diff --git a/x/staking/module.go b/x/staking/module.go index 49cfbf605..8dcb26c66 100644 --- a/x/staking/module.go +++ b/x/staking/module.go @@ -95,22 +95,22 @@ func (AppModuleBasic) BuildCreateValidatorMsg(cliCtx context.CLIContext, // app module type AppModule struct { AppModuleBasic - keeper Keeper - fcKeeper types.FeeCollectionKeeper - distrKeeper types.DistributionKeeper - accKeeper types.AccountKeeper + keeper Keeper + distrKeeper types.DistributionKeeper + accKeeper types.AccountKeeper + supplyKeeper types.SupplyKeeper } // NewAppModule creates a new AppModule object -func NewAppModule(keeper Keeper, fcKeeper types.FeeCollectionKeeper, - distrKeeper types.DistributionKeeper, accKeeper types.AccountKeeper) AppModule { +func NewAppModule(keeper Keeper, distrKeeper types.DistributionKeeper, accKeeper types.AccountKeeper, + supplyKeeper types.SupplyKeeper) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{}, keeper: keeper, - fcKeeper: fcKeeper, distrKeeper: distrKeeper, accKeeper: accKeeper, + supplyKeeper: supplyKeeper, } } @@ -121,7 +121,7 @@ func (AppModule) Name() string { // register invariants func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) { - RegisterInvariants(ir, am.keeper, am.fcKeeper, am.distrKeeper, am.accKeeper) + RegisterInvariants(ir, am.keeper) } // module message route name @@ -148,7 +148,7 @@ func (am AppModule) NewQuerierHandler() sdk.Querier { func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.ValidatorUpdate { var genesisState GenesisState ModuleCdc.MustUnmarshalJSON(data, &genesisState) - return InitGenesis(ctx, am.keeper, am.accKeeper, genesisState) + return InitGenesis(ctx, am.keeper, am.accKeeper, am.supplyKeeper, genesisState) } // module export genesis diff --git a/x/staking/types/expected_keepers.go b/x/staking/types/expected_keepers.go index ffbd6c58f..23da1ac5b 100644 --- a/x/staking/types/expected_keepers.go +++ b/x/staking/types/expected_keepers.go @@ -3,49 +3,57 @@ package types import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" + "github.com/cosmos/cosmos-sdk/x/supply" + supplyexported "github.com/cosmos/cosmos-sdk/x/supply/exported" ) -// expected coin keeper (noalias) +// DistributionKeeper expected distribution keeper (noalias) type DistributionKeeper interface { GetFeePoolCommunityCoins(ctx sdk.Context) sdk.DecCoins GetValidatorOutstandingRewardsCoins(ctx sdk.Context, val sdk.ValAddress) sdk.DecCoins } -// expected fee collection keeper (noalias) -type FeeCollectionKeeper interface { - GetCollectedFees(ctx sdk.Context) sdk.Coins -} - -// expected bank keeper (noalias) -type BankKeeper interface { - DelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error - UndelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error -} - -// AccountKeeper expected Account keeper +// AccountKeeper defines the expected account keeper (noalias) type AccountKeeper interface { IterateAccounts(ctx sdk.Context, process func(auth.Account) (stop bool)) } +// SupplyKeeper defines the expected supply Keeper (noalias) +type SupplyKeeper interface { + GetSupply(ctx sdk.Context) supply.Supply + + GetModuleAddress(name string) sdk.AccAddress + GetModuleAccount(ctx sdk.Context, moduleName string) supplyexported.ModuleAccountI + + // TODO remove with genesis 2-phases refactor https://github.com/cosmos/cosmos-sdk/issues/2862 + SetModuleAccount(sdk.Context, supplyexported.ModuleAccountI) + + SendCoinsFromModuleToModule(ctx sdk.Context, senderPool, recipientPool string, amt sdk.Coins) sdk.Error + UndelegateCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + DelegateCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) sdk.Error + + BurnCoins(ctx sdk.Context, name string, amt sdk.Coins) sdk.Error +} + // ValidatorSet expected properties for the set of all validators (noalias) type ValidatorSet interface { // iterate through validators by operator address, execute func for each validator IterateValidators(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) // iterate through bonded validators by operator address, execute func for each validator IterateBondedValidatorsByPower(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) // iterate through the consensus validator set of the last block by operator address, execute func for each validator IterateLastValidators(sdk.Context, - func(index int64, validator exported.ValidatorI) (stop bool)) + func(index int64, validator stakingexported.ValidatorI) (stop bool)) - Validator(sdk.Context, sdk.ValAddress) exported.ValidatorI // get a particular validator by operator address - ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) exported.ValidatorI // get a particular validator by consensus address - TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set - TotalTokens(sdk.Context) sdk.Int // total token supply + Validator(sdk.Context, sdk.ValAddress) stakingexported.ValidatorI // get a particular validator by operator address + ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingexported.ValidatorI // get a particular validator by consensus address + TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set + StakingTokenSupply(sdk.Context) sdk.Int // total staking token supply // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) @@ -54,7 +62,7 @@ type ValidatorSet interface { // Delegation allows for getting a particular delegation for a given validator // and delegator outside the scope of the staking module. - Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) exported.DelegationI + Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingexported.DelegationI // MaxValidators returns the maximum amount of bonded validators MaxValidators(sdk.Context) uint16 @@ -67,7 +75,7 @@ type DelegationSet interface { // iterate through all delegations from one delegator by validator-AccAddress, // execute func for each validator IterateDelegations(ctx sdk.Context, delegator sdk.AccAddress, - fn func(index int64, delegation exported.DelegationI) (stop bool)) + fn func(index int64, delegation stakingexported.DelegationI) (stop bool)) } //_______________________________________________________________________________ diff --git a/x/staking/types/genesis.go b/x/staking/types/genesis.go index e7c148346..dc5edf76c 100644 --- a/x/staking/types/genesis.go +++ b/x/staking/types/genesis.go @@ -6,7 +6,6 @@ import ( // GenesisState - all staking state that must be provided at genesis type GenesisState struct { - Pool Pool `json:"pool"` Params Params `json:"params"` LastTotalPower sdk.Int `json:"last_total_power"` LastValidatorPowers []LastValidatorPower `json:"last_validator_powers"` @@ -23,9 +22,8 @@ type LastValidatorPower struct { Power int64 } -func NewGenesisState(pool Pool, params Params, validators []Validator, delegations []Delegation) GenesisState { +func NewGenesisState(params Params, validators []Validator, delegations []Delegation) GenesisState { return GenesisState{ - Pool: pool, Params: params, Validators: validators, Delegations: delegations, @@ -35,7 +33,6 @@ func NewGenesisState(pool Pool, params Params, validators []Validator, delegatio // get raw genesis raw message for testing func DefaultGenesisState() GenesisState { return GenesisState{ - Pool: InitialPool(), Params: DefaultParams(), } } diff --git a/x/staking/types/pool.go b/x/staking/types/pool.go index 6ab2f17cd..03da4f3cb 100644 --- a/x/staking/types/pool.go +++ b/x/staking/types/pool.go @@ -1,92 +1,39 @@ package types import ( - "bytes" "fmt" - "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" ) +// names used as root for pool module accounts: +// +// - NotBondedPool -> "NotBondedTokensPool" +// +// - BondedPool -> "BondedTokensPool" +const ( + NotBondedPoolName = "NotBondedTokensPool" + BondedPoolName = "BondedTokensPool" +) + // Pool - tracking bonded and not-bonded token supply of the bond denomination type Pool struct { NotBondedTokens sdk.Int `json:"not_bonded_tokens"` // tokens which are not bonded to a validator (unbonded or unbonding) BondedTokens sdk.Int `json:"bonded_tokens"` // tokens which are currently bonded to a validator } -// nolint -// TODO: This is slower than comparing struct fields directly -func (p Pool) Equal(p2 Pool) bool { - bz1 := ModuleCdc.MustMarshalBinaryLengthPrefixed(&p) - bz2 := ModuleCdc.MustMarshalBinaryLengthPrefixed(&p2) - return bytes.Equal(bz1, bz2) -} - -// initial pool for testing -func InitialPool() Pool { +// NewPool creates a new Pool instance used for queries +func NewPool(notBonded, bonded sdk.Int) Pool { return Pool{ - NotBondedTokens: sdk.ZeroInt(), - BondedTokens: sdk.ZeroInt(), + NotBondedTokens: notBonded, + BondedTokens: bonded, } } -// Sum total of all staking tokens in the pool -func (p Pool) TokenSupply() sdk.Int { - return p.NotBondedTokens.Add(p.BondedTokens) -} - -// Get the fraction of the staking token which is currently bonded -func (p Pool) BondedRatio() sdk.Dec { - supply := p.TokenSupply() - if supply.IsPositive() { - return p.BondedTokens.ToDec().QuoInt(supply) - } - return sdk.ZeroDec() -} - -func (p Pool) notBondedTokensToBonded(bondedTokens sdk.Int) Pool { - p.BondedTokens = p.BondedTokens.Add(bondedTokens) - p.NotBondedTokens = p.NotBondedTokens.Sub(bondedTokens) - if p.NotBondedTokens.IsNegative() { - panic(fmt.Sprintf("sanity check: not-bonded tokens negative, pool: %v", p)) - } - return p -} - -func (p Pool) bondedTokensToNotBonded(bondedTokens sdk.Int) Pool { - p.BondedTokens = p.BondedTokens.Sub(bondedTokens) - p.NotBondedTokens = p.NotBondedTokens.Add(bondedTokens) - if p.BondedTokens.IsNegative() { - panic(fmt.Sprintf("sanity check: bonded tokens negative, pool: %v", p)) - } - return p -} - // String returns a human readable string representation of a pool. func (p Pool) String() string { - return fmt.Sprintf(`Pool: - Loose Tokens: %s - Bonded Tokens: %s - Token Supply: %s - Bonded Ratio: %v`, p.NotBondedTokens, - p.BondedTokens, p.TokenSupply(), - p.BondedRatio()) -} - -// unmarshal the current pool value from store key or panics -func MustUnmarshalPool(cdc *codec.Codec, value []byte) Pool { - pool, err := UnmarshalPool(cdc, value) - if err != nil { - panic(err) - } - return pool -} - -// unmarshal the current pool value from store key -func UnmarshalPool(cdc *codec.Codec, value []byte) (pool Pool, err error) { - err = cdc.UnmarshalBinaryLengthPrefixed(value, &pool) - if err != nil { - return - } - return + return fmt.Sprintf(`Pool: + Not Bonded Tokens: %s + Bonded Tokens: %s`, p.NotBondedTokens, + p.BondedTokens) } diff --git a/x/staking/types/pool_test.go b/x/staking/types/pool_test.go deleted file mode 100644 index ab0838fa6..000000000 --- a/x/staking/types/pool_test.go +++ /dev/null @@ -1,39 +0,0 @@ -package types - -import ( - "testing" - - "github.com/stretchr/testify/require" - - sdk "github.com/cosmos/cosmos-sdk/types" -) - -func TestPoolEqual(t *testing.T) { - p1 := InitialPool() - p2 := InitialPool() - require.True(t, p1.Equal(p2)) - p2.BondedTokens = sdk.NewInt(3) - require.False(t, p1.Equal(p2)) -} - -func TestAddBondedTokens(t *testing.T) { - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) - pool.BondedTokens = sdk.NewInt(10) - - pool = pool.notBondedTokensToBonded(sdk.NewInt(10)) - - require.True(sdk.IntEq(t, sdk.NewInt(20), pool.BondedTokens)) - require.True(sdk.IntEq(t, sdk.NewInt(0), pool.NotBondedTokens)) -} - -func TestRemoveBondedTokens(t *testing.T) { - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) - pool.BondedTokens = sdk.NewInt(10) - - pool = pool.bondedTokensToNotBonded(sdk.NewInt(5)) - - require.True(sdk.IntEq(t, sdk.NewInt(5), pool.BondedTokens)) - require.True(sdk.IntEq(t, sdk.NewInt(15), pool.NotBondedTokens)) -} diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index f91e12e3c..8dbea554e 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -336,57 +336,6 @@ func (v Validator) ABCIValidatorUpdateZero() abci.ValidatorUpdate { } } -// UpdateStatus updates the location of the shares within a validator -// to reflect the new status -func (v Validator) UpdateStatus(pool Pool, NewStatus sdk.BondStatus) (Validator, Pool) { - - switch v.Status { - case sdk.Unbonded: - - switch NewStatus { - case sdk.Unbonded: - return v, pool - case sdk.Bonded: - pool = pool.notBondedTokensToBonded(v.Tokens) - } - case sdk.Unbonding: - - switch NewStatus { - case sdk.Unbonding: - return v, pool - case sdk.Bonded: - pool = pool.notBondedTokensToBonded(v.Tokens) - } - case sdk.Bonded: - - switch NewStatus { - case sdk.Bonded: - return v, pool - default: - pool = pool.bondedTokensToNotBonded(v.Tokens) - } - } - - v.Status = NewStatus - return v, pool -} - -// removes tokens from a validator -func (v Validator) RemoveTokens(pool Pool, tokens sdk.Int) (Validator, Pool) { - if tokens.IsNegative() { - panic(fmt.Sprintf("should not happen: trying to remove negative tokens %v", tokens)) - } - if v.Tokens.LT(tokens) { - panic(fmt.Sprintf("should not happen: only have %v tokens, trying to remove %v", v.Tokens, tokens)) - } - v.Tokens = v.Tokens.Sub(tokens) - // TODO: It is not obvious from the name of the function that this will happen. Either justify or move outside. - if v.IsBonded() { - pool = pool.bondedTokensToNotBonded(tokens) - } - return v, pool -} - // SetInitialCommission attempts to set a validator's initial commission. An // error is returned if the commission is invalid. func (v Validator) SetInitialCommission(commission Commission) (Validator, sdk.Error) { @@ -398,66 +347,6 @@ func (v Validator) SetInitialCommission(commission Commission) (Validator, sdk.E return v, nil } -// AddTokensFromDel adds tokens to a validator -// CONTRACT: Tokens are assumed to have come from not-bonded pool. -func (v Validator) AddTokensFromDel(pool Pool, amount sdk.Int) (Validator, Pool, sdk.Dec) { - - // calculate the shares to issue - var issuedShares sdk.Dec - if v.DelegatorShares.IsZero() { - // the first delegation to a validator sets the exchange rate to one - issuedShares = amount.ToDec() - } else { - shares, err := v.SharesFromTokens(amount) - if err != nil { - panic(err) - } - - issuedShares = shares - } - - if v.IsBonded() { - pool = pool.notBondedTokensToBonded(amount) - } - - v.Tokens = v.Tokens.Add(amount) - v.DelegatorShares = v.DelegatorShares.Add(issuedShares) - - return v, pool, issuedShares -} - -// RemoveDelShares removes delegator shares from a validator. -// NOTE: because token fractions are left in the valiadator, -// the exchange rate of future shares of this validator can increase. -// CONTRACT: Tokens are assumed to move to the not-bonded pool. -func (v Validator) RemoveDelShares(pool Pool, delShares sdk.Dec) (Validator, Pool, sdk.Int) { - - remainingShares := v.DelegatorShares.Sub(delShares) - var issuedTokens sdk.Int - if remainingShares.IsZero() { - - // last delegation share gets any trimmings - issuedTokens = v.Tokens - v.Tokens = sdk.ZeroInt() - } else { - - // leave excess tokens in the validator - // however fully use all the delegator shares - issuedTokens = v.TokensFromShares(delShares).TruncateInt() - v.Tokens = v.Tokens.Sub(issuedTokens) - if v.Tokens.IsNegative() { - panic("attempting to remove more tokens than available in validator") - } - } - - v.DelegatorShares = remainingShares - if v.IsBonded() { - pool = pool.bondedTokensToNotBonded(issuedTokens) - } - - return v, pool, issuedTokens -} - // In some situations, the exchange rate becomes invalid, e.g. if // Validator loses all tokens due to slashing. In this case, // make all future delegations invalid. @@ -523,6 +412,75 @@ func (v Validator) PotentialConsensusPower() int64 { return sdk.TokensToConsensusPower(v.Tokens) } +// UpdateStatus updates the location of the shares within a validator +// to reflect the new status +func (v Validator) UpdateStatus(newStatus sdk.BondStatus) Validator { + v.Status = newStatus + return v +} + +// AddTokensFromDel adds tokens to a validator +func (v Validator) AddTokensFromDel(amount sdk.Int) (Validator, sdk.Dec) { + + // calculate the shares to issue + var issuedShares sdk.Dec + if v.DelegatorShares.IsZero() { + // the first delegation to a validator sets the exchange rate to one + issuedShares = amount.ToDec() + } else { + shares, err := v.SharesFromTokens(amount) + if err != nil { + panic(err) + } + + issuedShares = shares + } + + v.Tokens = v.Tokens.Add(amount) + v.DelegatorShares = v.DelegatorShares.Add(issuedShares) + + return v, issuedShares +} + +// RemoveTokens removes tokens from a validator +func (v Validator) RemoveTokens(tokens sdk.Int) Validator { + if tokens.IsNegative() { + panic(fmt.Sprintf("should not happen: trying to remove negative tokens %v", tokens)) + } + if v.Tokens.LT(tokens) { + panic(fmt.Sprintf("should not happen: only have %v tokens, trying to remove %v", v.Tokens, tokens)) + } + v.Tokens = v.Tokens.Sub(tokens) + return v +} + +// RemoveDelShares removes delegator shares from a validator. +// NOTE: because token fractions are left in the valiadator, +// the exchange rate of future shares of this validator can increase. +func (v Validator) RemoveDelShares(delShares sdk.Dec) (Validator, sdk.Int) { + + remainingShares := v.DelegatorShares.Sub(delShares) + var issuedTokens sdk.Int + if remainingShares.IsZero() { + + // last delegation share gets any trimmings + issuedTokens = v.Tokens + v.Tokens = sdk.ZeroInt() + } else { + + // leave excess tokens in the validator + // however fully use all the delegator shares + issuedTokens = v.TokensFromShares(delShares).TruncateInt() + v.Tokens = v.Tokens.Sub(issuedTokens) + if v.Tokens.IsNegative() { + panic("attempting to remove more tokens than available in validator") + } + } + + v.DelegatorShares = remainingShares + return v, issuedTokens +} + // nolint - for ValidatorI func (v Validator) IsJailed() bool { return v.Jailed } func (v Validator) GetMoniker() string { return v.Description.Moniker } diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go index af0842df0..cd9fcf791 100644 --- a/x/staking/types/validator_test.go +++ b/x/staking/types/validator_test.go @@ -87,46 +87,34 @@ func TestShareTokens(t *testing.T) { } func TestRemoveTokens(t *testing.T) { + valPubKey := pk1 + valAddr := sdk.ValAddress(valPubKey.Address().Bytes()) validator := Validator{ - OperatorAddress: valAddr1, - ConsPubKey: pk1, + OperatorAddress: valAddr, + ConsPubKey: valPubKey, Status: sdk.Bonded, Tokens: sdk.NewInt(100), DelegatorShares: sdk.NewDec(100), } - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) - pool.BondedTokens = validator.BondedTokens() - - validator, pool = validator.UpdateStatus(pool, sdk.Bonded) - require.Equal(t, sdk.Bonded, validator.Status) - // remove tokens and test check everything - validator, pool = validator.RemoveTokens(pool, sdk.NewInt(10)) + validator = validator.RemoveTokens(sdk.NewInt(10)) require.Equal(t, int64(90), validator.Tokens.Int64()) - require.Equal(t, int64(90), pool.BondedTokens.Int64()) - require.Equal(t, int64(20), pool.NotBondedTokens.Int64()) - // update validator to unbonded and remove some more tokens - validator, pool = validator.UpdateStatus(pool, sdk.Unbonded) + // update validator to from bonded -> unbonded + validator = validator.UpdateStatus(sdk.Unbonded) require.Equal(t, sdk.Unbonded, validator.Status) - require.Equal(t, int64(0), pool.BondedTokens.Int64()) - require.Equal(t, int64(110), pool.NotBondedTokens.Int64()) - validator, pool = validator.RemoveTokens(pool, sdk.NewInt(10)) - require.Equal(t, int64(80), validator.Tokens.Int64()) - require.Equal(t, int64(0), pool.BondedTokens.Int64()) - require.Equal(t, int64(110), pool.NotBondedTokens.Int64()) + validator = validator.RemoveTokens(sdk.NewInt(10)) + require.Panics(t, func() { validator.RemoveTokens(sdk.NewInt(-1)) }) + require.Panics(t, func() { validator.RemoveTokens(sdk.NewInt(100)) }) } func TestAddTokensValidatorBonded(t *testing.T) { - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) - validator := NewValidator(valAddr1, pk1, Description{}) - validator, pool = validator.UpdateStatus(pool, sdk.Bonded) - validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10)) + validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) + validator = validator.UpdateStatus(sdk.Bonded) + validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares)) assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens())) @@ -134,11 +122,9 @@ func TestAddTokensValidatorBonded(t *testing.T) { } func TestAddTokensValidatorUnbonding(t *testing.T) { - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) - validator := NewValidator(valAddr1, pk1, Description{}) - validator, pool = validator.UpdateStatus(pool, sdk.Unbonding) - validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10)) + validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) + validator = validator.UpdateStatus(sdk.Unbonding) + validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares)) assert.Equal(t, sdk.Unbonding, validator.Status) @@ -147,11 +133,10 @@ func TestAddTokensValidatorUnbonding(t *testing.T) { } func TestAddTokensValidatorUnbonded(t *testing.T) { - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) - validator := NewValidator(valAddr1, pk1, Description{}) - validator, pool = validator.UpdateStatus(pool, sdk.Unbonded) - validator, pool, delShares := validator.AddTokensFromDel(pool, sdk.NewInt(10)) + + validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) + validator = validator.UpdateStatus(sdk.Unbonded) + validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares)) assert.Equal(t, sdk.Unbonded, validator.Status) @@ -162,113 +147,80 @@ func TestAddTokensValidatorUnbonded(t *testing.T) { // TODO refactor to make simpler like the AddToken tests above func TestRemoveDelShares(t *testing.T) { valA := Validator{ - OperatorAddress: valAddr1, + OperatorAddress: sdk.ValAddress(pk1.Address().Bytes()), ConsPubKey: pk1, Status: sdk.Bonded, Tokens: sdk.NewInt(100), DelegatorShares: sdk.NewDec(100), } - poolA := InitialPool() - poolA.NotBondedTokens = sdk.NewInt(10) - poolA.BondedTokens = valA.BondedTokens() // Remove delegator shares - valB, poolB, coinsB := valA.RemoveDelShares(poolA, sdk.NewDec(10)) + valB, coinsB := valA.RemoveDelShares(sdk.NewDec(10)) require.Equal(t, int64(10), coinsB.Int64()) require.Equal(t, int64(90), valB.DelegatorShares.RoundInt64()) require.Equal(t, int64(90), valB.BondedTokens().Int64()) - require.Equal(t, int64(90), poolB.BondedTokens.Int64()) - require.Equal(t, int64(20), poolB.NotBondedTokens.Int64()) - - // conservation of tokens - require.True(sdk.IntEq(t, - poolB.NotBondedTokens.Add(poolB.BondedTokens), - poolA.NotBondedTokens.Add(poolA.BondedTokens))) // specific case from random tests poolTokens := sdk.NewInt(5102) delShares := sdk.NewDec(115) validator := Validator{ - OperatorAddress: valAddr1, + OperatorAddress: sdk.ValAddress(pk1.Address().Bytes()), ConsPubKey: pk1, Status: sdk.Bonded, Tokens: poolTokens, DelegatorShares: delShares, } - pool := Pool{ - BondedTokens: sdk.NewInt(248305), - NotBondedTokens: sdk.NewInt(232147), - } + shares := sdk.NewDec(29) - _, newPool, tokens := validator.RemoveDelShares(pool, shares) + _, tokens := validator.RemoveDelShares(shares) require.True(sdk.IntEq(t, sdk.NewInt(1286), tokens)) - - require.True(sdk.IntEq(t, - newPool.NotBondedTokens.Add(newPool.BondedTokens), - pool.NotBondedTokens.Add(pool.BondedTokens))) } func TestAddTokensFromDel(t *testing.T) { - val := NewValidator(valAddr1, pk1, Description{}) - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(10) + validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) - val, pool, shares := val.AddTokensFromDel(pool, sdk.NewInt(6)) + validator, shares := validator.AddTokensFromDel(sdk.NewInt(6)) require.True(sdk.DecEq(t, sdk.NewDec(6), shares)) - require.True(sdk.DecEq(t, sdk.NewDec(6), val.DelegatorShares)) - require.True(sdk.IntEq(t, sdk.NewInt(6), val.Tokens)) - require.True(sdk.IntEq(t, sdk.NewInt(0), pool.BondedTokens)) - require.True(sdk.IntEq(t, sdk.NewInt(10), pool.NotBondedTokens)) + require.True(sdk.DecEq(t, sdk.NewDec(6), validator.DelegatorShares)) + require.True(sdk.IntEq(t, sdk.NewInt(6), validator.Tokens)) - val, pool, shares = val.AddTokensFromDel(pool, sdk.NewInt(3)) + validator, shares = validator.AddTokensFromDel(sdk.NewInt(3)) require.True(sdk.DecEq(t, sdk.NewDec(3), shares)) - require.True(sdk.DecEq(t, sdk.NewDec(9), val.DelegatorShares)) - require.True(sdk.IntEq(t, sdk.NewInt(9), val.Tokens)) - require.True(sdk.IntEq(t, sdk.NewInt(0), pool.BondedTokens)) - require.True(sdk.IntEq(t, sdk.NewInt(10), pool.NotBondedTokens)) + require.True(sdk.DecEq(t, sdk.NewDec(9), validator.DelegatorShares)) + require.True(sdk.IntEq(t, sdk.NewInt(9), validator.Tokens)) } func TestUpdateStatus(t *testing.T) { - pool := InitialPool() - pool.NotBondedTokens = sdk.NewInt(100) - - validator := NewValidator(valAddr1, pk1, Description{}) - validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(100)) + validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) + validator, _ = validator.AddTokensFromDel(sdk.NewInt(100)) require.Equal(t, sdk.Unbonded, validator.Status) require.Equal(t, int64(100), validator.Tokens.Int64()) - require.Equal(t, int64(0), pool.BondedTokens.Int64()) - require.Equal(t, int64(100), pool.NotBondedTokens.Int64()) - validator, pool = validator.UpdateStatus(pool, sdk.Bonded) + // Unbonded to Bonded + validator = validator.UpdateStatus(sdk.Bonded) require.Equal(t, sdk.Bonded, validator.Status) - require.Equal(t, int64(100), validator.Tokens.Int64()) - require.Equal(t, int64(100), pool.BondedTokens.Int64()) - require.Equal(t, int64(0), pool.NotBondedTokens.Int64()) - validator, pool = validator.UpdateStatus(pool, sdk.Unbonding) + // Bonded to Unbonding + validator = validator.UpdateStatus(sdk.Unbonding) require.Equal(t, sdk.Unbonding, validator.Status) - require.Equal(t, int64(100), validator.Tokens.Int64()) - require.Equal(t, int64(0), pool.BondedTokens.Int64()) - require.Equal(t, int64(100), pool.NotBondedTokens.Int64()) + + // Unbonding to Bonded + validator = validator.UpdateStatus(sdk.Bonded) + require.Equal(t, sdk.Bonded, validator.Status) } func TestPossibleOverflow(t *testing.T) { - poolTokens := sdk.NewInt(2159) delShares := sdk.NewDec(391432570689183511).Quo(sdk.NewDec(40113011844664)) validator := Validator{ - OperatorAddress: valAddr1, + OperatorAddress: sdk.ValAddress(pk1.Address().Bytes()), ConsPubKey: pk1, Status: sdk.Bonded, - Tokens: poolTokens, + Tokens: sdk.NewInt(2159), DelegatorShares: delShares, } - pool := Pool{ - NotBondedTokens: sdk.NewInt(100), - BondedTokens: poolTokens, - } - tokens := int64(71) - newValidator, _, _ := validator.AddTokensFromDel(pool, sdk.NewInt(tokens)) + + newValidator, _ := validator.AddTokensFromDel(sdk.NewInt(71)) require.False(t, newValidator.DelegatorShares.IsNegative()) require.False(t, newValidator.Tokens.IsNegative()) diff --git a/x/supply/alias.go b/x/supply/alias.go new file mode 100644 index 000000000..6a0ebda3d --- /dev/null +++ b/x/supply/alias.go @@ -0,0 +1,49 @@ +// nolint +// autogenerated code using github.com/rigelrozanski/multitool +// aliases generated for the following subdirectories: +// ALIASGEN: github.com/cosmos/cosmos-sdk/x/supply/keeper +// ALIASGEN: github.com/cosmos/cosmos-sdk/x/supply/types +package supply + +import ( + "github.com/cosmos/cosmos-sdk/x/supply/keeper" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +const ( + ModuleName = types.ModuleName + StoreKey = types.StoreKey + RouterKey = types.RouterKey + QuerierRoute = types.QuerierRoute + Basic = types.Basic + Minter = types.Minter + Burner = types.Burner +) + +var ( + // functions aliases + RegisterInvariants = keeper.RegisterInvariants + AllInvariants = keeper.AllInvariants + TotalSupply = keeper.TotalSupply + NewKeeper = keeper.NewKeeper + SupplyKey = keeper.SupplyKey + NewModuleAddress = types.NewModuleAddress + NewEmptyModuleAccount = types.NewEmptyModuleAccount + NewModuleAccount = types.NewModuleAccount + RegisterCodec = types.RegisterCodec + NewGenesisState = types.NewGenesisState + DefaultGenesisState = types.DefaultGenesisState + NewSupply = types.NewSupply + DefaultSupply = types.DefaultSupply + + // variable aliases + DefaultCodespace = keeper.DefaultCodespace + ModuleCdc = types.ModuleCdc +) + +type ( + Keeper = keeper.Keeper + ModuleAccount = types.ModuleAccount + GenesisState = types.GenesisState + Supply = types.Supply +) diff --git a/x/supply/exported/exported.go b/x/supply/exported/exported.go new file mode 100644 index 000000000..c8f701ee4 --- /dev/null +++ b/x/supply/exported/exported.go @@ -0,0 +1,10 @@ +package exported + +import "github.com/cosmos/cosmos-sdk/x/auth/exported" + +// ModuleAccountI defines an account interface for modules that hold tokens in an escrow +type ModuleAccountI interface { + exported.Account + GetName() string + GetPermission() string +} diff --git a/x/supply/genesis.go b/x/supply/genesis.go new file mode 100644 index 000000000..7529e1590 --- /dev/null +++ b/x/supply/genesis.go @@ -0,0 +1,34 @@ +package supply + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + autypes "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +// InitGenesis sets supply information for genesis. +func InitGenesis(ctx sdk.Context, keeper Keeper, ak types.AccountKeeper, data GenesisState) { + // manually set the total supply based on accounts if not provided + if data.Supply.Total.Empty() { + var totalSupply sdk.Coins + ak.IterateAccounts(ctx, + func(acc autypes.Account) (stop bool) { + totalSupply = totalSupply.Add(acc.GetCoins()) + return false + }, + ) + data.Supply.Total = totalSupply + } + keeper.SetSupply(ctx, data.Supply) +} + +// ExportGenesis returns a GenesisState for a given context and keeper. +func ExportGenesis(ctx sdk.Context, keeper Keeper) GenesisState { + return NewGenesisState(keeper.GetSupply(ctx)) +} + +// ValidateGenesis performs basic validation of supply genesis data returning an +// error for any failed validation criteria. +func ValidateGenesis(data GenesisState) error { + return data.Supply.ValidateBasic() +} diff --git a/x/supply/keeper/account.go b/x/supply/keeper/account.go new file mode 100644 index 000000000..165888c56 --- /dev/null +++ b/x/supply/keeper/account.go @@ -0,0 +1,60 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/exported" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +// GetModuleAddress returns a an address based on the name +func (k Keeper) GetModuleAddress(moduleName string) sdk.AccAddress { + permAddr, ok := k.permAddrs[moduleName] + if !ok { + return nil + } + return permAddr.address +} + +// GetModuleAddressAndPermission returns an address and permission based on the name +func (k Keeper) GetModuleAddressAndPermission(moduleName string) (addr sdk.AccAddress, permission string) { + permAddr, ok := k.permAddrs[moduleName] + if !ok { + return nil, "" + } + return permAddr.address, permAddr.permission +} + +// GetModuleAccount gets the module account to the auth account store +func (k Keeper) GetModuleAccountAndPermission(ctx sdk.Context, moduleName string) (exported.ModuleAccountI, string) { + addr, perm := k.GetModuleAddressAndPermission(moduleName) + if addr == nil { + return nil, "" + } + + acc := k.ak.GetAccount(ctx, addr) + if acc != nil { + macc, ok := acc.(exported.ModuleAccountI) + if !ok { + panic("account is not a module account") + } + return macc, perm + } + + // create a new module account + macc := types.NewEmptyModuleAccount(moduleName, perm) + maccI := (k.ak.NewAccount(ctx, macc)).(exported.ModuleAccountI) // set the account number + k.SetModuleAccount(ctx, maccI) + + return maccI, perm +} + +// GetModuleAccount gets the module account to the auth account store +func (k Keeper) GetModuleAccount(ctx sdk.Context, moduleName string) exported.ModuleAccountI { + acc, _ := k.GetModuleAccountAndPermission(ctx, moduleName) + return acc +} + +// SetModuleAccount sets the module account to the auth account store +func (k Keeper) SetModuleAccount(ctx sdk.Context, macc exported.ModuleAccountI) { + k.ak.SetAccount(ctx, macc) +} diff --git a/x/supply/keeper/bank.go b/x/supply/keeper/bank.go new file mode 100644 index 000000000..17e3a16d7 --- /dev/null +++ b/x/supply/keeper/bank.go @@ -0,0 +1,142 @@ +package keeper + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +// SendCoinsFromModuleToAccount transfers coins from a ModuleAccount to an AccAddress +func (k Keeper) SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, + recipientAddr sdk.AccAddress, amt sdk.Coins) sdk.Error { + + senderAddr := k.GetModuleAddress(senderModule) + if senderAddr == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", senderModule)) + } + + return k.bk.SendCoins(ctx, senderAddr, recipientAddr, amt) +} + +// SendCoinsFromModuleToModule transfers coins from a ModuleAccount to another +func (k Keeper) SendCoinsFromModuleToModule(ctx sdk.Context, senderModule, recipientModule string, amt sdk.Coins) sdk.Error { + + senderAddr := k.GetModuleAddress(senderModule) + if senderAddr == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", senderModule)) + } + + // create the account if it doesn't yet exist + recipientAddr := k.GetModuleAccount(ctx, recipientModule).GetAddress() + if recipientAddr == nil { + panic(fmt.Sprintf("module account %s isn't able to be created", recipientModule)) + } + + return k.bk.SendCoins(ctx, senderAddr, recipientAddr, amt) +} + +// SendCoinsFromAccountToModule transfers coins from an AccAddress to a ModuleAccount +func (k Keeper) SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, + recipientModule string, amt sdk.Coins) sdk.Error { + + // create the account if it doesn't yet exist + recipientAddr := k.GetModuleAccount(ctx, recipientModule).GetAddress() + if recipientAddr == nil { + panic(fmt.Sprintf("module account %s isn't able to be created", recipientModule)) + } + + return k.bk.SendCoins(ctx, senderAddr, recipientAddr, amt) +} + +// DelegateCoinsFromAccountToModule delegates coins and transfers +// them from a delegator account to a module account +func (k Keeper) DelegateCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, + recipientModule string, amt sdk.Coins) sdk.Error { + + // create the account if it doesn't yet exist + recipientAddr := k.GetModuleAccount(ctx, recipientModule).GetAddress() + if recipientAddr == nil { + panic(fmt.Sprintf("module account %s isn't able to be created", recipientModule)) + } + + return k.bk.DelegateCoins(ctx, senderAddr, recipientAddr, amt) +} + +// UndelegateCoinsFromModuleToAccount undelegates the unbonding coins and transfers +// them from a module account to the delegator account +func (k Keeper) UndelegateCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, + recipientAddr sdk.AccAddress, amt sdk.Coins) sdk.Error { + + senderAddr := k.GetModuleAddress(senderModule) + if senderAddr == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", senderModule)) + } + + return k.bk.UndelegateCoins(ctx, senderAddr, recipientAddr, amt) +} + +// MintCoins creates new coins from thin air and adds it to the MinterAccount. +// Panics if the name maps to a non-minter module account. +func (k Keeper) MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) sdk.Error { + if amt.Empty() { + panic("cannot mint empty coins") + } + + // create the account if it doesn't yet exist + acc, perm := k.GetModuleAccountAndPermission(ctx, moduleName) + addr := acc.GetAddress() + if addr == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", moduleName)) + } + + if perm != types.Minter { + panic(fmt.Sprintf("Account %s does not have permissions to mint tokens", moduleName)) + } + + _, err := k.bk.AddCoins(ctx, addr, amt) + if err != nil { + return err + } + + // update total supply + supply := k.GetSupply(ctx) + supply.Inflate(amt) + k.SetSupply(ctx, supply) + + logger := k.Logger(ctx) + logger.Info(fmt.Sprintf("minted %s from %s module account", amt.String(), moduleName)) + + return nil +} + +// BurnCoins burns coins deletes coins from the balance of the module account +func (k Keeper) BurnCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) sdk.Error { + if amt.Empty() { + panic("cannot burn empty coins") + } + + addr, perm := k.GetModuleAddressAndPermission(moduleName) + if addr == nil { + return sdk.ErrUnknownAddress(fmt.Sprintf("module account %s does not exist", moduleName)) + } + + if perm != types.Burner { + panic(fmt.Sprintf("Account %s does not have permissions to burn tokens", moduleName)) + } + + _, err := k.bk.SubtractCoins(ctx, addr, amt) + if err != nil { + return err + } + + // update total supply + supply := k.GetSupply(ctx) + supply.Deflate(amt) + k.SetSupply(ctx, supply) + + logger := k.Logger(ctx) + logger.Info(fmt.Sprintf("burned %s from %s module account", amt.String(), moduleName)) + + return nil +} diff --git a/x/supply/keeper/bank_test.go b/x/supply/keeper/bank_test.go new file mode 100644 index 000000000..d10ef09c9 --- /dev/null +++ b/x/supply/keeper/bank_test.go @@ -0,0 +1,115 @@ +package keeper + +import ( + "testing" + + "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +const initialPower = int64(100) + +var ( + holderAcc = types.NewEmptyModuleAccount(types.Basic, types.Basic) + burnerAcc = types.NewEmptyModuleAccount(types.Burner, types.Burner) + minterAcc = types.NewEmptyModuleAccount(types.Minter, types.Minter) + + initTokens = sdk.TokensFromConsensusPower(initialPower) + initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens)) +) + +func getCoinsByName(ctx sdk.Context, k Keeper, moduleName string) sdk.Coins { + moduleAddress := k.GetModuleAddress(moduleName) + macc := k.ak.GetAccount(ctx, moduleAddress) + if macc == nil { + return sdk.Coins(nil) + } + return macc.GetCoins() +} + +func TestSendCoins(t *testing.T) { + nAccs := int64(4) + ctx, ak, keeper := createTestInput(t, false, initialPower, nAccs) + + baseAcc := ak.NewAccountWithAddress(ctx, types.NewModuleAddress("baseAcc")) + + err := holderAcc.SetCoins(initCoins) + require.NoError(t, err) + + keeper.SetModuleAccount(ctx, holderAcc) + keeper.SetModuleAccount(ctx, burnerAcc) + ak.SetAccount(ctx, baseAcc) + + err = keeper.SendCoinsFromModuleToModule(ctx, "", types.Basic, initCoins) + require.Error(t, err) + + require.Panics(t, func() { + keeper.SendCoinsFromModuleToModule(ctx, types.Burner, "", initCoins) + }) + + err = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins) + require.Error(t, err) + + err = keeper.SendCoinsFromModuleToAccount(ctx, types.Basic, baseAcc.GetAddress(), initCoins.Add(initCoins)) + require.Error(t, err) + + err = keeper.SendCoinsFromModuleToModule(ctx, types.Basic, types.Burner, initCoins) + require.NoError(t, err) + require.Equal(t, sdk.Coins(nil), getCoinsByName(ctx, keeper, types.Basic)) + require.Equal(t, initCoins, getCoinsByName(ctx, keeper, types.Burner)) + + err = keeper.SendCoinsFromModuleToAccount(ctx, types.Burner, baseAcc.GetAddress(), initCoins) + require.NoError(t, err) + require.Equal(t, sdk.Coins(nil), getCoinsByName(ctx, keeper, types.Burner)) + require.Equal(t, initCoins, keeper.bk.GetCoins(ctx, baseAcc.GetAddress())) + + err = keeper.SendCoinsFromAccountToModule(ctx, baseAcc.GetAddress(), types.Burner, initCoins) + require.NoError(t, err) + require.Equal(t, sdk.Coins(nil), keeper.bk.GetCoins(ctx, baseAcc.GetAddress())) + require.Equal(t, initCoins, getCoinsByName(ctx, keeper, types.Burner)) +} + +func TestMintCoins(t *testing.T) { + nAccs := int64(4) + ctx, _, keeper := createTestInput(t, false, initialPower, nAccs) + + keeper.SetModuleAccount(ctx, burnerAcc) + keeper.SetModuleAccount(ctx, minterAcc) + + initialSupply := keeper.GetSupply(ctx) + + require.Panics(t, func() { keeper.MintCoins(ctx, "", initCoins) }) + + err := keeper.MintCoins(ctx, types.Minter, initCoins) + require.NoError(t, err) + require.Equal(t, initCoins, getCoinsByName(ctx, keeper, types.Minter)) + require.Equal(t, initialSupply.Total.Add(initCoins), keeper.GetSupply(ctx).Total) + + require.Panics(t, func() { keeper.MintCoins(ctx, types.Burner, initCoins) }) +} + +func TestBurnCoins(t *testing.T) { + nAccs := int64(4) + ctx, _, keeper := createTestInput(t, false, initialPower, nAccs) + + err := burnerAcc.SetCoins(initCoins) + require.NoError(t, err) + keeper.SetModuleAccount(ctx, burnerAcc) + + initialSupply := keeper.GetSupply(ctx) + initialSupply.Inflate(initCoins) + keeper.SetSupply(ctx, initialSupply) + + err = keeper.BurnCoins(ctx, "", initCoins) + require.Error(t, err) + + err = keeper.BurnCoins(ctx, types.Burner, initialSupply.Total) + require.Error(t, err) + + err = keeper.BurnCoins(ctx, types.Burner, initCoins) + require.NoError(t, err) + require.Equal(t, sdk.Coins(nil), getCoinsByName(ctx, keeper, types.Burner)) + require.Equal(t, initialSupply.Total.Sub(initCoins), keeper.GetSupply(ctx).Total) +} diff --git a/x/supply/keeper/invariants.go b/x/supply/keeper/invariants.go new file mode 100644 index 000000000..6122d7b80 --- /dev/null +++ b/x/supply/keeper/invariants.go @@ -0,0 +1,42 @@ +package keeper + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth/exported" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +// RegisterInvariants register all supply invariants +func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper) { + ir.RegisterRoute(types.ModuleName, "total-supply", TotalSupply(k)) +} + +// AllInvariants runs all invariants of the supply module. +func AllInvariants(k Keeper) sdk.Invariant { + return func(ctx sdk.Context) error { + return TotalSupply(k)(ctx) + } +} + +// TotalSupply checks that the total supply reflects all the coins held in accounts +func TotalSupply(k Keeper) sdk.Invariant { + return func(ctx sdk.Context) error { + var expectedTotal sdk.Coins + supply := k.GetSupply(ctx) + + k.ak.IterateAccounts(ctx, func(acc exported.Account) bool { + expectedTotal = expectedTotal.Add(acc.GetCoins()) + return false + }) + + if !expectedTotal.IsEqual(supply.Total) { + return fmt.Errorf("total supply invariance:\n"+ + "\tsum of accounts coins: %v\n"+ + "\tsupply.Total: %v", expectedTotal, supply.Total) + } + + return nil + } +} diff --git a/x/supply/keeper/keeper.go b/x/supply/keeper/keeper.go new file mode 100644 index 000000000..d47f0a027 --- /dev/null +++ b/x/supply/keeper/keeper.go @@ -0,0 +1,81 @@ +package keeper + +import ( + "fmt" + + "github.com/tendermint/tendermint/libs/log" + + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +// Keeper of the supply store +type Keeper struct { + cdc *codec.Codec + storeKey sdk.StoreKey + ak types.AccountKeeper + bk types.BankKeeper + permAddrs map[string]permAddr +} + +type permAddr struct { + permission string // basic/minter/burner + address sdk.AccAddress +} + +// NewpermAddr creates a new permAddr object +func newPermAddr(permission, name string) permAddr { + return permAddr{ + permission: permission, + address: types.NewModuleAddress(name), + } +} + +// NewKeeper creates a new Keeper instance +func NewKeeper(cdc *codec.Codec, key sdk.StoreKey, ak types.AccountKeeper, bk types.BankKeeper, + codespace sdk.CodespaceType, basicModuleAccs, minterModuleAccs, burnerModuleAccs []string) Keeper { + + // set the addresses + permAddrs := make(map[string]permAddr) + for _, name := range basicModuleAccs { + permAddrs[name] = newPermAddr(types.Basic, name) + } + for _, name := range minterModuleAccs { + permAddrs[name] = newPermAddr(types.Minter, name) + } + for _, name := range burnerModuleAccs { + permAddrs[name] = newPermAddr(types.Burner, name) + } + + return Keeper{ + cdc: cdc, + storeKey: key, + ak: ak, + bk: bk, + permAddrs: permAddrs, + } +} + +// Logger returns a module-specific logger. +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName)) +} + +// GetSupply retrieves the Supply from store +func (k Keeper) GetSupply(ctx sdk.Context) (supply types.Supply) { + store := ctx.KVStore(k.storeKey) + b := store.Get(SupplyKey) + if b == nil { + panic("stored supply should not have been nil") + } + k.cdc.MustUnmarshalBinaryLengthPrefixed(b, &supply) + return +} + +// SetSupply sets the Supply to store +func (k Keeper) SetSupply(ctx sdk.Context, supply types.Supply) { + store := ctx.KVStore(k.storeKey) + b := k.cdc.MustMarshalBinaryLengthPrefixed(supply) + store.Set(SupplyKey, b) +} diff --git a/x/supply/keeper/keeper_test.go b/x/supply/keeper/keeper_test.go new file mode 100644 index 000000000..4e458eeb4 --- /dev/null +++ b/x/supply/keeper/keeper_test.go @@ -0,0 +1,22 @@ +package keeper + +import ( + "testing" + + "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func TestSupply(t *testing.T) { + initialPower := int64(100) + initTokens := sdk.TokensFromConsensusPower(initialPower) + nAccs := int64(4) + + ctx, _, keeper := createTestInput(t, false, initialPower, nAccs) + + total := keeper.GetSupply(ctx).Total + expectedTotal := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens.MulRaw(nAccs))) + + require.Equal(t, expectedTotal, total) +} diff --git a/x/supply/keeper/key.go b/x/supply/keeper/key.go new file mode 100644 index 000000000..460bfcd97 --- /dev/null +++ b/x/supply/keeper/key.go @@ -0,0 +1,17 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +// DefaultCodespace from the supply module +var DefaultCodespace sdk.CodespaceType = types.ModuleName + +// Keys for supply store +// Items are stored with the following key: values +// +// - 0x00: Supply +var ( + SupplyKey = []byte{0x00} +) diff --git a/x/supply/keeper/test_common.go b/x/supply/keeper/test_common.go new file mode 100644 index 000000000..2235f7452 --- /dev/null +++ b/x/supply/keeper/test_common.go @@ -0,0 +1,94 @@ +package keeper + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/crypto/secp256k1" + dbm "github.com/tendermint/tendermint/libs/db" + "github.com/tendermint/tendermint/libs/log" + + abci "github.com/tendermint/tendermint/abci/types" + tmtypes "github.com/tendermint/tendermint/types" + + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/bank" + "github.com/cosmos/cosmos-sdk/x/params" + "github.com/cosmos/cosmos-sdk/x/supply/types" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// nolint: deadcode unused +// create a codec used only for testing +func makeTestCodec() *codec.Codec { + var cdc = codec.New() + + bank.RegisterCodec(cdc) + auth.RegisterCodec(cdc) + types.RegisterCodec(cdc) + sdk.RegisterCodec(cdc) + codec.RegisterCrypto(cdc) + + return cdc +} + +// nolint: deadcode unused +func createTestInput(t *testing.T, isCheckTx bool, initPower int64, nAccs int64) (sdk.Context, auth.AccountKeeper, Keeper) { + + keyAcc := sdk.NewKVStoreKey(auth.StoreKey) + keyParams := sdk.NewKVStoreKey(params.StoreKey) + tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey) + keySupply := sdk.NewKVStoreKey(types.StoreKey) + + db := dbm.NewMemDB() + ms := store.NewCommitMultiStore(db) + ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db) + ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db) + ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db) + ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db) + err := ms.LoadLatestVersion() + require.Nil(t, err) + + ctx := sdk.NewContext(ms, abci.Header{ChainID: "supply-chain"}, isCheckTx, log.NewNopLogger()) + ctx = ctx.WithConsensusParams( + &abci.ConsensusParams{ + Validator: &abci.ValidatorParams{ + PubKeyTypes: []string{tmtypes.ABCIPubKeyTypeEd25519}, + }, + }, + ) + cdc := makeTestCodec() + + pk := params.NewKeeper(cdc, keyParams, tkeyParams, params.DefaultCodespace) + ak := auth.NewAccountKeeper(cdc, keyAcc, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount) + bk := bank.NewBaseKeeper(ak, pk.Subspace(bank.DefaultParamspace), bank.DefaultCodespace) + + valTokens := sdk.TokensFromConsensusPower(initPower) + + initialCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, valTokens)) + createTestAccs(ctx, int(nAccs), initialCoins, &ak) + + keeper := NewKeeper(cdc, keySupply, ak, bk, DefaultCodespace, []string{types.Basic}, []string{types.Minter}, []string{types.Burner}) + totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, valTokens.MulRaw(nAccs))) + keeper.SetSupply(ctx, types.NewSupply(totalSupply)) + + return ctx, ak, keeper +} + +// nolint: unparam deadcode unused +func createTestAccs(ctx sdk.Context, numAccs int, initialCoins sdk.Coins, ak *auth.AccountKeeper) (accs []auth.Account) { + for i := 0; i < numAccs; i++ { + privKey := secp256k1.GenPrivKey() + pubKey := privKey.PubKey() + addr := sdk.AccAddress(pubKey.Address()) + acc := auth.NewBaseAccountWithAddress(addr) + acc.Coins = initialCoins + acc.PubKey = pubKey + acc.AccountNumber = uint64(i) + ak.SetAccount(ctx, &acc) + } + return +} diff --git a/x/supply/module.go b/x/supply/module.go new file mode 100644 index 000000000..208a2dbe2 --- /dev/null +++ b/x/supply/module.go @@ -0,0 +1,127 @@ +package supply + +import ( + "encoding/json" + + "github.com/gorilla/mux" + "github.com/spf13/cobra" + + abci "github.com/tendermint/tendermint/abci/types" + + "github.com/cosmos/cosmos-sdk/client/context" + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + "github.com/cosmos/cosmos-sdk/x/supply/types" +) + +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} +) + +// app module basics object +type AppModuleBasic struct{} + +// module name +func (AppModuleBasic) Name() string { + return ModuleName +} + +// register module codec +func (AppModuleBasic) RegisterCodec(cdc *codec.Codec) { + RegisterCodec(cdc) +} + +// default genesis state +func (AppModuleBasic) DefaultGenesis() json.RawMessage { + return ModuleCdc.MustMarshalJSON(DefaultGenesisState()) +} + +// module validate genesis +func (AppModuleBasic) ValidateGenesis(bz json.RawMessage) error { + var data GenesisState + err := ModuleCdc.UnmarshalJSON(bz, &data) + if err != nil { + return err + } + return ValidateGenesis(data) +} + +// register rest routes +func (AppModuleBasic) RegisterRESTRoutes(_ context.CLIContext, _ *mux.Router) { +} + +// get the root tx command of this module +func (AppModuleBasic) GetTxCmd(_ *codec.Codec) *cobra.Command { return nil } + +// get the root query command of this module +func (AppModuleBasic) GetQueryCmd(_ *codec.Codec) *cobra.Command { + return nil +} + +// app module +type AppModule struct { + AppModuleBasic + keeper Keeper + ak types.AccountKeeper +} + +// NewAppModule creates a new AppModule object +func NewAppModule(keeper Keeper, ak types.AccountKeeper) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{}, + keeper: keeper, + ak: ak, + } +} + +// module name +func (AppModule) Name() string { + return ModuleName +} + +// register invariants +func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) { + RegisterInvariants(ir, am.keeper) +} + +// module message route name +func (AppModule) Route() string { + return RouterKey +} + +// module handler +func (am AppModule) NewHandler() sdk.Handler { return nil } + +// module querier route name +func (AppModule) QuerierRoute() string { + return QuerierRoute +} + +// module querier +func (am AppModule) NewQuerierHandler() sdk.Querier { + return nil +} + +// module init-genesis +func (am AppModule) InitGenesis(ctx sdk.Context, data json.RawMessage) []abci.ValidatorUpdate { + var genesisState GenesisState + ModuleCdc.MustUnmarshalJSON(data, &genesisState) + InitGenesis(ctx, am.keeper, am.ak, genesisState) + return []abci.ValidatorUpdate{} +} + +// module export genesis +func (am AppModule) ExportGenesis(ctx sdk.Context) json.RawMessage { + gs := ExportGenesis(ctx, am.keeper) + return ModuleCdc.MustMarshalJSON(gs) +} + +// module begin-block +func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {} + +// module end-block +func (AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate { + return []abci.ValidatorUpdate{} +} diff --git a/x/supply/types/account.go b/x/supply/types/account.go new file mode 100644 index 000000000..55a1bf1bd --- /dev/null +++ b/x/supply/types/account.go @@ -0,0 +1,113 @@ +package types + +import ( + "fmt" + + yaml "gopkg.in/yaml.v2" + + "github.com/tendermint/tendermint/crypto" + + sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/cosmos/cosmos-sdk/x/supply/exported" +) + +var _ exported.ModuleAccountI = (*ModuleAccount)(nil) + +// ModuleAccount defines an account for modules that holds coins on a pool +type ModuleAccount struct { + *authtypes.BaseAccount + Name string `json:"name"` // name of the module + Permission string `json:"permission"` // permission of module account (minter/burner/holder) +} + +// NewModuleAddress creates an AccAddress from the hash of the module's name +func NewModuleAddress(name string) sdk.AccAddress { + return sdk.AccAddress(crypto.AddressHash([]byte(name))) +} + +func NewEmptyModuleAccount(name, permission string) *ModuleAccount { + moduleAddress := NewModuleAddress(name) + baseAcc := authtypes.NewBaseAccountWithAddress(moduleAddress) + + if err := validatePermissions(permission); err != nil { + panic(err) + } + + return &ModuleAccount{ + BaseAccount: &baseAcc, + Name: name, + Permission: permission, + } +} + +// NewModuleAccount creates a new ModuleAccount instance +func NewModuleAccount(ba *authtypes.BaseAccount, + name, permission string) *ModuleAccount { + + if err := validatePermissions(permission); err != nil { + panic(err) + } + + return &ModuleAccount{ + BaseAccount: ba, + Name: name, + Permission: permission, + } +} + +// GetName returns the the name of the holder's module +func (ma ModuleAccount) GetName() string { + return ma.Name +} + +// GetPermission returns permission granted to the module account (holder/minter/burner) +func (ma ModuleAccount) GetPermission() string { + return ma.Permission +} + +// SetPubKey - Implements Account +func (ma ModuleAccount) SetPubKey(pubKey crypto.PubKey) error { + return fmt.Errorf("not supported for module accounts") +} + +// SetSequence - Implements Account +func (ma ModuleAccount) SetSequence(seq uint64) error { + return fmt.Errorf("not supported for module accounts") +} + +// String follows stringer interface +func (ma ModuleAccount) String() string { + b, err := yaml.Marshal(ma) + if err != nil { + panic(err) + } + return string(b) +} + +// MarshalYAML returns the YAML representation of a ModuleAccount. +func (ma ModuleAccount) MarshalYAML() (interface{}, error) { + bs, err := yaml.Marshal(struct { + Address sdk.AccAddress + Coins sdk.Coins + PubKey string + AccountNumber uint64 + Sequence uint64 + Name string + Permission string + }{ + Address: ma.Address, + Coins: ma.Coins, + PubKey: "", + AccountNumber: ma.AccountNumber, + Sequence: ma.Sequence, + Name: ma.Name, + Permission: ma.Permission, + }) + + if err != nil { + return nil, err + } + + return string(bs), nil +} diff --git a/x/supply/types/account_test.go b/x/supply/types/account_test.go new file mode 100644 index 000000000..d239b53e6 --- /dev/null +++ b/x/supply/types/account_test.go @@ -0,0 +1,33 @@ +package types + +import ( + "fmt" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/tendermint/tendermint/crypto" + "gopkg.in/yaml.v2" + + "github.com/stretchr/testify/require" +) + +func TestModuleAccountMarshalYAML(t *testing.T) { + name := "test" + moduleAcc := NewEmptyModuleAccount(name, Basic) + moduleAddress := sdk.AccAddress(crypto.AddressHash([]byte(name))) + bs, err := yaml.Marshal(moduleAcc) + require.NoError(t, err) + + want := fmt.Sprintf(`| + address: %s + coins: [] + pubkey: "" + accountnumber: 0 + sequence: 0 + name: %s + permission: %s +`, moduleAddress, name, Basic) + + require.Equal(t, want, string(bs)) + require.Equal(t, want, moduleAcc.String()) +} diff --git a/x/supply/types/codec.go b/x/supply/types/codec.go new file mode 100644 index 000000000..1b9c9183c --- /dev/null +++ b/x/supply/types/codec.go @@ -0,0 +1,22 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/x/supply/exported" +) + +// RegisterCodec registers the account types and interface +func RegisterCodec(cdc *codec.Codec) { + cdc.RegisterInterface((*exported.ModuleAccountI)(nil), nil) + cdc.RegisterConcrete(&ModuleAccount{}, "cosmos-sdk/ModuleAccount", nil) +} + +// ModuleCdc generic sealed codec to be used throughout module +var ModuleCdc *codec.Codec + +func init() { + cdc := codec.New() + RegisterCodec(cdc) + codec.RegisterCrypto(cdc) + ModuleCdc = cdc.Seal() +} diff --git a/x/supply/types/expected_keepers.go b/x/supply/types/expected_keepers.go new file mode 100644 index 000000000..5c11f1994 --- /dev/null +++ b/x/supply/types/expected_keepers.go @@ -0,0 +1,25 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth/exported" +) + +// AccountKeeper defines the expected account keeper (noalias) +type AccountKeeper interface { + IterateAccounts(ctx sdk.Context, process func(exported.Account) (stop bool)) + GetAccount(sdk.Context, sdk.AccAddress) exported.Account + SetAccount(sdk.Context, exported.Account) + NewAccount(sdk.Context, exported.Account) exported.Account +} + +// BankKeeper defines the expected bank keeper (noalias) +type BankKeeper interface { + GetCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins + SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + DelegateCoins(ctx sdk.Context, fromAdd, toAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + UndelegateCoins(ctx sdk.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) sdk.Error + + SubtractCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Error) + AddCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Error) +} diff --git a/x/supply/types/genesis.go b/x/supply/types/genesis.go new file mode 100644 index 000000000..ed0188fc4 --- /dev/null +++ b/x/supply/types/genesis.go @@ -0,0 +1,16 @@ +package types + +// GenesisState is the supply state that must be provided at genesis. +type GenesisState struct { + Supply Supply `json:"supply"` +} + +// NewGenesisState creates a new genesis state. +func NewGenesisState(supply Supply) GenesisState { + return GenesisState{supply} +} + +// DefaultGenesisState returns a default genesis state +func DefaultGenesisState() GenesisState { + return NewGenesisState(DefaultSupply()) +} diff --git a/x/supply/types/key.go b/x/supply/types/key.go new file mode 100644 index 000000000..60501a78c --- /dev/null +++ b/x/supply/types/key.go @@ -0,0 +1,15 @@ +package types + +const ( + // ModuleName is the module name constant used in many places + ModuleName = "supply" + + // StoreKey is the store key string for supply + StoreKey = ModuleName + + // RouterKey is the message route for supply + RouterKey = ModuleName + + // QuerierRoute is the querier route for supply + QuerierRoute = ModuleName +) diff --git a/x/supply/types/permissions.go b/x/supply/types/permissions.go new file mode 100644 index 000000000..d2198e039 --- /dev/null +++ b/x/supply/types/permissions.go @@ -0,0 +1,20 @@ +package types + +import "fmt" + +// permissions +const ( + Basic = "basic" + Minter = "minter" + Burner = "burner" +) + +// validate the input permissions +func validatePermissions(permission string) error { + switch permission { + case Basic, Minter, Burner: + return nil + default: + return fmt.Errorf("invalid module permission %s", permission) + } +} diff --git a/x/supply/types/supply.go b/x/supply/types/supply.go new file mode 100644 index 000000000..9a02c6608 --- /dev/null +++ b/x/supply/types/supply.go @@ -0,0 +1,46 @@ +package types + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + yaml "gopkg.in/yaml.v2" +) + +// Supply represents a struct that passively keeps track of the total supply amounts in the network +type Supply struct { + Total sdk.Coins `json:"total_supply"` // total supply of tokens registered on the chain +} + +// NewSupply creates a new Supply instance +func NewSupply(total sdk.Coins) Supply { return Supply{total} } + +// DefaultSupply creates an empty Supply +func DefaultSupply() Supply { return NewSupply(sdk.NewCoins()) } + +// Inflate adds coins to the total supply +func (supply *Supply) Inflate(amount sdk.Coins) { + supply.Total = supply.Total.Add(amount) +} + +// Deflate subtracts coins from the total supply +func (supply *Supply) Deflate(amount sdk.Coins) { + supply.Total = supply.Total.Sub(amount) +} + +// String returns a human readable string representation of a supplier. +func (supply Supply) String() string { + b, err := yaml.Marshal(supply) + if err != nil { + panic(err) + } + return string(b) +} + +// ValidateBasic validates the Supply coins and returns error if invalid +func (supply Supply) ValidateBasic() error { + if !supply.Total.IsValid() { + return fmt.Errorf("invalid total supply: %s", supply.Total.String()) + } + return nil +} diff --git a/x/supply/types/supply_test.go b/x/supply/types/supply_test.go new file mode 100644 index 000000000..68e007323 --- /dev/null +++ b/x/supply/types/supply_test.go @@ -0,0 +1,28 @@ +package types + +import ( + "fmt" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "gopkg.in/yaml.v2" + + "github.com/stretchr/testify/require" +) + +func TestSupplyMarshalYAML(t *testing.T) { + supply := DefaultSupply() + coins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt())) + supply.Inflate(coins) + + bz, err := yaml.Marshal(supply) + require.NoError(t, err) + bzCoins, err := yaml.Marshal(coins) + require.NoError(t, err) + + want := fmt.Sprintf(`total: +%s`, string(bzCoins)) + + require.Equal(t, want, string(bz)) + require.Equal(t, want, supply.String()) +}