179 lines
6.8 KiB
Go
179 lines
6.8 KiB
Go
package keeper
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/crypto"
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
dbm "github.com/tendermint/tm-db"
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
simappcodec "github.com/cosmos/cosmos-sdk/simapp/codec"
|
|
"github.com/cosmos/cosmos-sdk/store"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/x/auth"
|
|
"github.com/cosmos/cosmos-sdk/x/bank"
|
|
"github.com/cosmos/cosmos-sdk/x/distribution/types"
|
|
"github.com/cosmos/cosmos-sdk/x/params/keeper"
|
|
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
|
|
"github.com/cosmos/cosmos-sdk/x/staking"
|
|
"github.com/cosmos/cosmos-sdk/x/supply"
|
|
)
|
|
|
|
//nolint:deadcode,unused
|
|
var (
|
|
delPk1 = ed25519.GenPrivKey().PubKey()
|
|
delPk2 = ed25519.GenPrivKey().PubKey()
|
|
delPk3 = ed25519.GenPrivKey().PubKey()
|
|
delAddr1 = sdk.AccAddress(delPk1.Address())
|
|
delAddr2 = sdk.AccAddress(delPk2.Address())
|
|
delAddr3 = sdk.AccAddress(delPk3.Address())
|
|
|
|
valOpPk1 = ed25519.GenPrivKey().PubKey()
|
|
valOpPk2 = ed25519.GenPrivKey().PubKey()
|
|
valOpPk3 = ed25519.GenPrivKey().PubKey()
|
|
valOpAddr1 = sdk.ValAddress(valOpPk1.Address())
|
|
valOpAddr2 = sdk.ValAddress(valOpPk2.Address())
|
|
valOpAddr3 = sdk.ValAddress(valOpPk3.Address())
|
|
valAccAddr1 = sdk.AccAddress(valOpPk1.Address()) // generate acc addresses for these validator keys too
|
|
valAccAddr2 = sdk.AccAddress(valOpPk2.Address())
|
|
valAccAddr3 = sdk.AccAddress(valOpPk3.Address())
|
|
|
|
valConsPk1 = ed25519.GenPrivKey().PubKey()
|
|
valConsPk2 = ed25519.GenPrivKey().PubKey()
|
|
valConsPk3 = ed25519.GenPrivKey().PubKey()
|
|
valConsAddr1 = sdk.ConsAddress(valConsPk1.Address())
|
|
valConsAddr2 = sdk.ConsAddress(valConsPk2.Address())
|
|
|
|
// TODO move to common testing package for all modules
|
|
// test addresses
|
|
TestAddrs = []sdk.AccAddress{
|
|
delAddr1, delAddr2, delAddr3,
|
|
valAccAddr1, valAccAddr2, valAccAddr3,
|
|
}
|
|
pubkeys = []crypto.PubKey{
|
|
delPk1, delPk2, delPk3, valOpPk1, valOpPk2, valOpPk3,
|
|
}
|
|
|
|
distrAcc = supply.NewEmptyModuleAccount(types.ModuleName)
|
|
)
|
|
|
|
// create a codec used only for testing
|
|
func MakeTestCodec() *codec.Codec {
|
|
var cdc = codec.New()
|
|
bank.RegisterCodec(cdc)
|
|
staking.RegisterCodec(cdc)
|
|
auth.RegisterCodec(cdc)
|
|
supply.RegisterCodec(cdc)
|
|
sdk.RegisterCodec(cdc)
|
|
codec.RegisterCrypto(cdc)
|
|
|
|
types.RegisterCodec(cdc) // distr
|
|
return cdc
|
|
}
|
|
|
|
// test input with default values
|
|
func CreateTestInputDefault(t *testing.T, isCheckTx bool, initPower int64) (
|
|
sdk.Context, auth.AccountKeeper, bank.Keeper, Keeper, staking.Keeper, types.SupplyKeeper) {
|
|
|
|
communityTax := sdk.NewDecWithPrec(2, 2)
|
|
|
|
ctx, ak, bk, dk, sk, _, supplyKeeper := CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax)
|
|
return ctx, ak, bk, 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, keeper.Keeper, types.SupplyKeeper,
|
|
) {
|
|
|
|
initTokens := sdk.TokensFromConsensusPower(initPower)
|
|
|
|
keyBank := sdk.NewKVStoreKey(bank.StoreKey)
|
|
keyDistr := sdk.NewKVStoreKey(types.StoreKey)
|
|
keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
|
|
keyAcc := sdk.NewKVStoreKey(auth.StoreKey)
|
|
keySupply := sdk.NewKVStoreKey(supply.StoreKey)
|
|
keyParams := sdk.NewKVStoreKey(paramtypes.StoreKey)
|
|
tkeyParams := sdk.NewTransientStoreKey(paramtypes.TStoreKey)
|
|
|
|
db := dbm.NewMemDB()
|
|
ms := store.NewCommitMultiStore(db)
|
|
|
|
ms.MountStoreWithDB(keyBank, sdk.StoreTypeIAVL, db)
|
|
ms.MountStoreWithDB(keyDistr, sdk.StoreTypeIAVL, db)
|
|
ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db)
|
|
ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db)
|
|
ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db)
|
|
ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db)
|
|
ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db)
|
|
|
|
err := ms.LoadLatestVersion()
|
|
require.Nil(t, err)
|
|
|
|
feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName)
|
|
notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner, supply.Staking)
|
|
bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner, supply.Staking)
|
|
|
|
blacklistedAddrs := make(map[string]bool)
|
|
blacklistedAddrs[feeCollectorAcc.GetAddress().String()] = true
|
|
blacklistedAddrs[notBondedPool.GetAddress().String()] = true
|
|
blacklistedAddrs[bondPool.GetAddress().String()] = true
|
|
blacklistedAddrs[distrAcc.GetAddress().String()] = true
|
|
|
|
cdc := MakeTestCodec()
|
|
appCodec := simappcodec.NewAppCodec(cdc)
|
|
pk := keeper.NewKeeper(appCodec, keyParams, tkeyParams)
|
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, log.NewNopLogger())
|
|
accountKeeper := auth.NewAccountKeeper(appCodec, keyAcc, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount)
|
|
bankKeeper := bank.NewBaseKeeper(appCodec, keyBank, accountKeeper, pk.Subspace(bank.DefaultParamspace), blacklistedAddrs)
|
|
maccPerms := map[string][]string{
|
|
auth.FeeCollectorName: nil,
|
|
types.ModuleName: nil,
|
|
staking.NotBondedPoolName: {supply.Burner, supply.Staking},
|
|
staking.BondedPoolName: {supply.Burner, supply.Staking},
|
|
}
|
|
supplyKeeper := supply.NewKeeper(appCodec, keySupply, accountKeeper, bankKeeper, maccPerms)
|
|
|
|
sk := staking.NewKeeper(staking.ModuleCdc, keyStaking, bankKeeper, supplyKeeper, pk.Subspace(staking.DefaultParamspace))
|
|
sk.SetParams(ctx, staking.DefaultParams())
|
|
|
|
keeper := NewKeeper(types.ModuleCdc, keyDistr, pk.Subspace(types.DefaultParamspace), bankKeeper, sk, supplyKeeper, auth.FeeCollectorName, blacklistedAddrs)
|
|
|
|
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 i, addr := range TestAddrs {
|
|
accountKeeper.SetAccount(ctx, auth.NewBaseAccount(addr, pubkeys[i], uint64(i), 0))
|
|
require.NoError(t, bankKeeper.SetBalances(ctx, addr, initCoins))
|
|
}
|
|
|
|
// set module accounts
|
|
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())
|
|
|
|
// set genesis items required for distribution
|
|
keeper.SetFeePool(ctx, types.InitialFeePool())
|
|
|
|
params := types.DefaultParams()
|
|
params.CommunityTax = communityTax
|
|
params.BaseProposerReward = sdk.NewDecWithPrec(1, 2)
|
|
params.BonusProposerReward = sdk.NewDecWithPrec(4, 2)
|
|
keeper.SetParams(ctx, params)
|
|
|
|
return ctx, accountKeeper, bankKeeper, keeper, sk, pk, supplyKeeper
|
|
}
|