github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/x/gov/keeper/test_common.go (about)

     1  // nolint
     2  package keeper // noalias
     3  
     4  // DONTCOVER
     5  
     6  import (
     7  	"bytes"
     8  	"encoding/hex"
     9  	"testing"
    10  
    11  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/store/mpt"
    12  
    13  	"github.com/stretchr/testify/require"
    14  
    15  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto"
    16  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto/ed25519"
    17  
    18  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
    19  	"github.com/fibonacci-chain/fbc/libs/tendermint/libs/log"
    20  	tmtypes "github.com/fibonacci-chain/fbc/libs/tendermint/types"
    21  	dbm "github.com/fibonacci-chain/fbc/libs/tm-db"
    22  
    23  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/codec"
    24  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/store"
    25  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    26  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/auth"
    27  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/bank"
    28  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/gov/types"
    29  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/params"
    30  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/staking"
    31  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/supply"
    32  )
    33  
    34  // dummy addresses used for testing
    35  var (
    36  	delPk1   = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB51")
    37  	delPk2   = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB50")
    38  	delPk3   = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB52")
    39  	delAddr1 = sdk.AccAddress(delPk1.Address())
    40  	delAddr2 = sdk.AccAddress(delPk2.Address())
    41  	delAddr3 = sdk.AccAddress(delPk3.Address())
    42  
    43  	valOpPk1    = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB53")
    44  	valOpPk2    = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB54")
    45  	valOpPk3    = newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB55")
    46  	valOpAddr1  = sdk.ValAddress(valOpPk1.Address())
    47  	valOpAddr2  = sdk.ValAddress(valOpPk2.Address())
    48  	valOpAddr3  = sdk.ValAddress(valOpPk3.Address())
    49  	valAccAddr1 = sdk.AccAddress(valOpPk1.Address())
    50  	valAccAddr2 = sdk.AccAddress(valOpPk2.Address())
    51  	valAccAddr3 = sdk.AccAddress(valOpPk3.Address())
    52  
    53  	TestAddrs = []sdk.AccAddress{
    54  		delAddr1, delAddr2, delAddr3,
    55  		valAccAddr1, valAccAddr2, valAccAddr3,
    56  	}
    57  
    58  	emptyDelAddr sdk.AccAddress
    59  	emptyValAddr sdk.ValAddress
    60  	emptyPubkey  crypto.PubKey
    61  )
    62  
    63  // TODO: remove dependency with staking
    64  var (
    65  	TestProposal        = types.NewTextProposal("Test", "description")
    66  	TestDescription     = staking.NewDescription("T", "E", "S", "T", "Z")
    67  	TestCommissionRates = staking.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
    68  )
    69  
    70  // TODO move to common testing framework
    71  func newPubKey(pk string) (res crypto.PubKey) {
    72  	pkBytes, err := hex.DecodeString(pk)
    73  	if err != nil {
    74  		panic(err)
    75  	}
    76  	var pkEd ed25519.PubKeyEd25519
    77  	copy(pkEd[:], pkBytes[:])
    78  	return pkEd
    79  }
    80  
    81  func makeTestCodec() *codec.Codec {
    82  	var cdc = codec.New()
    83  	auth.RegisterCodec(cdc)
    84  	types.RegisterCodec(cdc)
    85  	supply.RegisterCodec(cdc)
    86  	staking.RegisterCodec(cdc)
    87  	sdk.RegisterCodec(cdc)
    88  	codec.RegisterCrypto(cdc)
    89  
    90  	return cdc
    91  }
    92  
    93  func createTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, types.SupplyKeeper) {
    94  
    95  	initTokens := sdk.TokensFromConsensusPower(initPower)
    96  
    97  	keyAcc := sdk.NewKVStoreKey(auth.StoreKey)
    98  	keyMpt := sdk.NewKVStoreKey(mpt.StoreKey)
    99  	keyGov := sdk.NewKVStoreKey(types.StoreKey)
   100  	keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
   101  	keySupply := sdk.NewKVStoreKey(supply.StoreKey)
   102  	keyParams := sdk.NewKVStoreKey(params.StoreKey)
   103  	tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey)
   104  
   105  	db := dbm.NewMemDB()
   106  	ms := store.NewCommitMultiStore(db)
   107  
   108  	ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db)
   109  	ms.MountStoreWithDB(keyMpt, sdk.StoreTypeMPT, db)
   110  	ms.MountStoreWithDB(keySupply, sdk.StoreTypeIAVL, db)
   111  	ms.MountStoreWithDB(keyGov, sdk.StoreTypeIAVL, db)
   112  	ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db)
   113  	ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db)
   114  	ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db)
   115  	require.Nil(t, ms.LoadLatestVersion())
   116  
   117  	ctx := sdk.NewContext(ms, abci.Header{ChainID: "gov-chain"}, isCheckTx, log.NewNopLogger())
   118  	ctx.SetConsensusParams(
   119  		&abci.ConsensusParams{
   120  			Validator: &abci.ValidatorParams{
   121  				PubKeyTypes: []string{tmtypes.ABCIPubKeyTypeEd25519},
   122  			},
   123  		},
   124  	)
   125  	cdc := makeTestCodec()
   126  
   127  	maccPerms := map[string][]string{
   128  		auth.FeeCollectorName:     nil,
   129  		types.ModuleName:          nil,
   130  		staking.NotBondedPoolName: {supply.Burner, supply.Staking},
   131  		staking.BondedPoolName:    {supply.Burner, supply.Staking},
   132  	}
   133  
   134  	// create module accounts
   135  	feeCollectorAcc := supply.NewEmptyModuleAccount(auth.FeeCollectorName)
   136  	govAcc := supply.NewEmptyModuleAccount(types.ModuleName, supply.Burner)
   137  	notBondedPool := supply.NewEmptyModuleAccount(staking.NotBondedPoolName, supply.Burner, supply.Staking)
   138  	bondPool := supply.NewEmptyModuleAccount(staking.BondedPoolName, supply.Burner, supply.Staking)
   139  
   140  	blacklistedAddrs := make(map[string]bool)
   141  	blacklistedAddrs[feeCollectorAcc.GetAddress().String()] = true
   142  	blacklistedAddrs[govAcc.GetAddress().String()] = true
   143  	blacklistedAddrs[notBondedPool.GetAddress().String()] = true
   144  	blacklistedAddrs[bondPool.GetAddress().String()] = true
   145  
   146  	pk := params.NewKeeper(cdc, keyParams, tkeyParams)
   147  	accountKeeper := auth.NewAccountKeeper(cdc, keyAcc, keyMpt, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount)
   148  	bankKeeper := bank.NewBaseKeeper(accountKeeper, pk.Subspace(bank.DefaultParamspace), blacklistedAddrs)
   149  	supplyKeeper := supply.NewKeeper(cdc, keySupply, accountKeeper, bank.NewBankKeeperAdapter(bankKeeper), maccPerms)
   150  
   151  	sk := staking.NewKeeper(cdc, keyStaking, supplyKeeper, pk.Subspace(staking.DefaultParamspace))
   152  	sk.SetParams(ctx, staking.DefaultParams())
   153  
   154  	rtr := types.NewRouter().
   155  		AddRoute(types.RouterKey, types.ProposalHandler)
   156  
   157  	keeper := NewKeeper(
   158  		cdc, keyGov, pk.Subspace(types.DefaultParamspace).WithKeyTable(types.ParamKeyTable()), supplyKeeper, sk, rtr,
   159  	)
   160  
   161  	keeper.SetProposalID(ctx, types.DefaultStartingProposalID)
   162  	keeper.SetDepositParams(ctx, types.DefaultDepositParams())
   163  	keeper.SetVotingParams(ctx, types.DefaultVotingParams())
   164  	keeper.SetTallyParams(ctx, types.DefaultTallyParams())
   165  
   166  	initCoins := sdk.NewCoins(sdk.NewCoin(sk.BondDenom(ctx), initTokens))
   167  	totalSupply := sdk.NewCoins(sdk.NewCoin(sk.BondDenom(ctx), initTokens.MulRaw(int64(len(TestAddrs)))))
   168  	supplyKeeper.SetSupply(ctx, supply.NewSupply(totalSupply))
   169  
   170  	for _, addr := range TestAddrs {
   171  		_, err := bankKeeper.AddCoins(ctx, addr, initCoins)
   172  		require.Nil(t, err)
   173  	}
   174  
   175  	keeper.supplyKeeper.SetModuleAccount(ctx, feeCollectorAcc)
   176  	keeper.supplyKeeper.SetModuleAccount(ctx, govAcc)
   177  	keeper.supplyKeeper.SetModuleAccount(ctx, bondPool)
   178  	keeper.supplyKeeper.SetModuleAccount(ctx, notBondedPool)
   179  
   180  	return ctx, accountKeeper, keeper, sk, supplyKeeper
   181  }
   182  
   183  // ProposalEqual checks if two proposals are equal (note: slow, for tests only)
   184  func ProposalEqual(proposalA types.Proposal, proposalB types.Proposal) bool {
   185  	return bytes.Equal(types.ModuleCdc.MustMarshalBinaryBare(proposalA),
   186  		types.ModuleCdc.MustMarshalBinaryBare(proposalB))
   187  }
   188  
   189  func createValidators(ctx sdk.Context, sk staking.Keeper, powers []int64) {
   190  	val1 := staking.NewValidator(valOpAddr1, valOpPk1, staking.Description{})
   191  	val2 := staking.NewValidator(valOpAddr2, valOpPk2, staking.Description{})
   192  	val3 := staking.NewValidator(valOpAddr3, valOpPk3, staking.Description{})
   193  
   194  	sk.SetValidator(ctx, val1)
   195  	sk.SetValidator(ctx, val2)
   196  	sk.SetValidator(ctx, val3)
   197  	sk.SetValidatorByConsAddr(ctx, val1)
   198  	sk.SetValidatorByConsAddr(ctx, val2)
   199  	sk.SetValidatorByConsAddr(ctx, val3)
   200  	sk.SetNewValidatorByPowerIndex(ctx, val1)
   201  	sk.SetNewValidatorByPowerIndex(ctx, val2)
   202  	sk.SetNewValidatorByPowerIndex(ctx, val3)
   203  
   204  	_, _ = sk.Delegate(ctx, valAccAddr1, sdk.TokensFromConsensusPower(powers[0]).ToDec(), sdk.Unbonded, val1, true)
   205  	_, _ = sk.Delegate(ctx, valAccAddr2, sdk.TokensFromConsensusPower(powers[1]).ToDec(), sdk.Unbonded, val2, true)
   206  	_, _ = sk.Delegate(ctx, valAccAddr3, sdk.TokensFromConsensusPower(powers[2]).ToDec(), sdk.Unbonded, val3, true)
   207  
   208  	_ = staking.EndBlocker(ctx, sk)
   209  }