From 634f626799abb8bcda086be3c5580afdddac3f4e Mon Sep 17 00:00:00 2001 From: stackman27 Date: Tue, 6 Sep 2022 18:03:04 -0700 Subject: [PATCH] Module Wired up and created MsgSetValidatorSetPreference --- app/keepers/keepers.go | 56 +-- go.mod | 1 + go.sum | 3 + .../validator-preference/v1beta1/params.proto | 16 + x/validator-preference/keeper/ValidatorSet.go | 45 +++ x/validator-preference/keeper/keeper.go | 57 +++ x/validator-preference/keeper/keeper_test.go | 67 ++++ x/validator-preference/keeper/msg_server.go | 60 ++++ .../keeper/msg_server_test.go | 124 +++++++ x/validator-preference/types/codec.go | 30 ++ x/validator-preference/types/errors.go | 1 + .../types/expected_interfaces.go | 17 + x/validator-preference/types/keys.go | 15 + x/validator-preference/types/msgs.go | 84 +++++ x/validator-preference/types/params.go | 32 ++ x/validator-preference/types/params.pb.go | 335 ++++++++++++++++++ .../valpref-module/module.go | 212 +++++++++++ 17 files changed, 1133 insertions(+), 22 deletions(-) create mode 100644 proto/osmosis/validator-preference/v1beta1/params.proto create mode 100644 x/validator-preference/keeper/ValidatorSet.go create mode 100644 x/validator-preference/keeper/keeper.go create mode 100644 x/validator-preference/keeper/keeper_test.go create mode 100644 x/validator-preference/keeper/msg_server.go create mode 100644 x/validator-preference/keeper/msg_server_test.go create mode 100644 x/validator-preference/types/codec.go create mode 100644 x/validator-preference/types/errors.go create mode 100644 x/validator-preference/types/expected_interfaces.go create mode 100644 x/validator-preference/types/keys.go create mode 100644 x/validator-preference/types/msgs.go create mode 100644 x/validator-preference/types/params.go create mode 100644 x/validator-preference/types/params.pb.go create mode 100644 x/validator-preference/valpref-module/module.go diff --git a/app/keepers/keepers.go b/app/keepers/keepers.go index c0d94c5d18b..4c3ee44dd29 100644 --- a/app/keepers/keepers.go +++ b/app/keepers/keepers.go @@ -72,6 +72,8 @@ import ( "github.com/osmosis-labs/osmosis/v12/x/txfees" txfeeskeeper "github.com/osmosis-labs/osmosis/v12/x/txfees/keeper" txfeestypes "github.com/osmosis-labs/osmosis/v12/x/txfees/types" + validatorpreferencekeeper "github.com/osmosis-labs/osmosis/v12/x/validator-preference/keeper" + validatorpreferencetypes "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types" ) type AppKeepers struct { @@ -89,28 +91,29 @@ type AppKeepers struct { ScopedWasmKeeper capabilitykeeper.ScopedKeeper // "Normal" keepers - AccountKeeper *authkeeper.AccountKeeper - BankKeeper *bankkeeper.BaseKeeper - AuthzKeeper *authzkeeper.Keeper - StakingKeeper *stakingkeeper.Keeper - DistrKeeper *distrkeeper.Keeper - SlashingKeeper *slashingkeeper.Keeper - IBCKeeper *ibckeeper.Keeper - ICAHostKeeper *icahostkeeper.Keeper - TransferKeeper *ibctransferkeeper.Keeper - EvidenceKeeper *evidencekeeper.Keeper - GAMMKeeper *gammkeeper.Keeper - TwapKeeper *twap.Keeper - LockupKeeper *lockupkeeper.Keeper - EpochsKeeper *epochskeeper.Keeper - IncentivesKeeper *incentiveskeeper.Keeper - MintKeeper *mintkeeper.Keeper - PoolIncentivesKeeper *poolincentiveskeeper.Keeper - TxFeesKeeper *txfeeskeeper.Keeper - SuperfluidKeeper *superfluidkeeper.Keeper - GovKeeper *govkeeper.Keeper - WasmKeeper *wasm.Keeper - TokenFactoryKeeper *tokenfactorykeeper.Keeper + AccountKeeper *authkeeper.AccountKeeper + BankKeeper *bankkeeper.BaseKeeper + AuthzKeeper *authzkeeper.Keeper + StakingKeeper *stakingkeeper.Keeper + DistrKeeper *distrkeeper.Keeper + SlashingKeeper *slashingkeeper.Keeper + IBCKeeper *ibckeeper.Keeper + ICAHostKeeper *icahostkeeper.Keeper + TransferKeeper *ibctransferkeeper.Keeper + EvidenceKeeper *evidencekeeper.Keeper + GAMMKeeper *gammkeeper.Keeper + TwapKeeper *twap.Keeper + LockupKeeper *lockupkeeper.Keeper + EpochsKeeper *epochskeeper.Keeper + IncentivesKeeper *incentiveskeeper.Keeper + MintKeeper *mintkeeper.Keeper + PoolIncentivesKeeper *poolincentiveskeeper.Keeper + TxFeesKeeper *txfeeskeeper.Keeper + SuperfluidKeeper *superfluidkeeper.Keeper + GovKeeper *govkeeper.Keeper + WasmKeeper *wasm.Keeper + TokenFactoryKeeper *tokenfactorykeeper.Keeper + ValidatorPreferenceKeeper *validatorpreferencekeeper.Keeper // IBC modules // transfer module TransferModule transfer.AppModule @@ -321,6 +324,14 @@ func (appKeepers *AppKeepers) InitNormalKeepers( ) appKeepers.TokenFactoryKeeper = &tokenFactoryKeeper + validatorPreferenceKeeper := validatorpreferencekeeper.NewKeeper( + appKeepers.keys[validatorpreferencetypes.StoreKey], + appKeepers.GetSubspace(validatorpreferencetypes.ModuleName), + appKeepers.StakingKeeper, + ) + + appKeepers.ValidatorPreferenceKeeper = &validatorPreferenceKeeper + // The last arguments can contain custom message handlers, and custom query handlers, // if we want to allow any custom callbacks supportedFeatures := "iterator,staking,stargate,osmosis" @@ -534,5 +545,6 @@ func KVStoreKeys() []string { superfluidtypes.StoreKey, wasm.StoreKey, tokenfactorytypes.StoreKey, + validatorpreferencetypes.StoreKey, } } diff --git a/go.mod b/go.mod index e4e7141ed36..9551a3c14b7 100644 --- a/go.mod +++ b/go.mod @@ -18,6 +18,7 @@ require ( github.com/mattn/go-sqlite3 v1.14.15 github.com/ory/dockertest/v3 v3.9.1 github.com/osmosis-labs/go-mutesting v0.0.0-20220811235203-65a53b4ea8e3 + github.com/osmosis-labs/osmosis/v11 v11.0.1 github.com/pkg/errors v0.9.1 github.com/rakyll/statik v0.1.7 github.com/spf13/cast v1.5.0 diff --git a/go.sum b/go.sum index 5b486c6d5b2..2b2ea4648bd 100644 --- a/go.sum +++ b/go.sum @@ -876,12 +876,15 @@ github.com/ory/dockertest v3.3.5+incompatible h1:iLLK6SQwIhcbrG783Dghaaa3WPzGc+4 github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs= github.com/ory/dockertest/v3 v3.9.1 h1:v4dkG+dlu76goxMiTT2j8zV7s4oPPEppKT8K8p2f1kY= github.com/ory/dockertest/v3 v3.9.1/go.mod h1:42Ir9hmvaAPm0Mgibk6mBPi7SFvTXxEcnztDYOJ//uM= +github.com/osmosis-labs/bech32-ibc v0.3.0-rc1 h1:frHKHEdPfzoK2iMF2GeWKudLLzUXz+6GJcdZ/TMcs2k= github.com/osmosis-labs/cosmos-sdk v0.45.1-0.20220921135931-3c4d30596acc h1:WPsgSEDb4RsdUxhy7qmKU++kZ07mMHFVMeSl8Hp808w= github.com/osmosis-labs/cosmos-sdk v0.45.1-0.20220921135931-3c4d30596acc/go.mod h1:uUkGXyCWol+CHoaMxZA0nKglvlN5uHBCMbMSsZoGSAs= github.com/osmosis-labs/go-mutesting v0.0.0-20220811235203-65a53b4ea8e3 h1:/imbKy8s1I+z7wx4FbRHOXK2v82xesUCz2EPUqfBDIg= github.com/osmosis-labs/go-mutesting v0.0.0-20220811235203-65a53b4ea8e3/go.mod h1:lV6KnqXYD/ayTe7310MHtM3I2q8Z6bBfMAi+bhwPYtI= github.com/osmosis-labs/iavl v0.17.3-osmo-v7 h1:6KcADC/WhL7yDmNQxUIJt2XmzNt4FfRmq9gRke45w74= github.com/osmosis-labs/iavl v0.17.3-osmo-v7/go.mod h1:lJEOIlsd3sVO0JDyXWIXa9/Ur5FBscP26zJx0KxHjto= +github.com/osmosis-labs/osmosis/v11 v11.0.1 h1:xGuaDCcDtdrkJ6pISfipKw9/3T23QIH9GqOAz7ld/3M= +github.com/osmosis-labs/osmosis/v11 v11.0.1/go.mod h1:KoFJzMYRxK9a0+cQrR+FaODbzfgkQHiYnlX4pHm8vCs= github.com/osmosis-labs/wasmd v0.28.0-osmo-v12.1 h1:CZJSa65banZjQNyDhp+nGPr9MRYrIfOU/aO3ww2V1Rg= github.com/osmosis-labs/wasmd v0.28.0-osmo-v12.1/go.mod h1:7YWBfoD6zPuu6pmqnq/kMNpc+xqOaxEtolJ5/7xHzB8= github.com/otiai10/copy v1.2.0/go.mod h1:rrF5dJ5F0t/EWSYODDu4j9/vEeYHMkc8jt0zJChqQWw= diff --git a/proto/osmosis/validator-preference/v1beta1/params.proto b/proto/osmosis/validator-preference/v1beta1/params.proto new file mode 100644 index 00000000000..7445358e913 --- /dev/null +++ b/proto/osmosis/validator-preference/v1beta1/params.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; +package osmosis.validatorpreference.v1beta1; + +import "gogoproto/gogo.proto"; +import "osmosis/validator-preference/v1beta1/state.proto"; + +option go_package = "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types"; + +// Params defines the parameters for the module. +message Params { + // the users validator-set, {valAddr, weight} to unstake the tokens from. + repeated ValidatorPreference preferences = 1 [ + (gogoproto.moretags) = "yaml:\"preferences\"", + (gogoproto.nullable) = false + ]; +} diff --git a/x/validator-preference/keeper/ValidatorSet.go b/x/validator-preference/keeper/ValidatorSet.go new file mode 100644 index 00000000000..2f15194e817 --- /dev/null +++ b/x/validator-preference/keeper/ValidatorSet.go @@ -0,0 +1,45 @@ +package keeper + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types" +) + +// ValidateValidator checks if the validator address is valid and the validator provided exists onchain. +func (k Keeper) ValidateValidator(ctx sdk.Context, valOperAddress string) (sdk.ValAddress, stakingtypes.Validator, error) { + valAddr, err := sdk.ValAddressFromBech32(valOperAddress) + if err != nil { + return nil, stakingtypes.Validator{}, fmt.Errorf("validator address not formatted") + } + + validator, found := k.stakingKeeper.GetValidator(ctx, valAddr) + if !found { + return nil, stakingtypes.Validator{}, fmt.Errorf("validator not found %s", validator) + } + + return valAddr, validator, nil +} + +// ValidatePreferences checks if the sum of the validator set equals 1. +func (k Keeper) ValidatePreferences(ctx sdk.Context, preferences []types.ValidatorPreference) error { + total_weight := sdk.NewDec(0) + for _, val := range preferences { + // validation to check that the validator given is valid + _, _, err := k.ValidateValidator(ctx, val.ValOperAddress) + if err != nil { + return err + } + + total_weight = total_weight.Add(val.Weight) + } + + // check if the total validator distribution weights equal 1 + if !total_weight.Equal(sdk.NewDec(1)) { + return fmt.Errorf("The weights allocated to the validators do not add up to 1, %d", total_weight) + } + + return nil +} diff --git a/x/validator-preference/keeper/keeper.go b/x/validator-preference/keeper/keeper.go new file mode 100644 index 00000000000..67a578c9cee --- /dev/null +++ b/x/validator-preference/keeper/keeper.go @@ -0,0 +1,57 @@ +package keeper + +import ( + "fmt" + + "github.com/tendermint/tendermint/libs/log" + + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + "github.com/gogo/protobuf/proto" + "github.com/osmosis-labs/osmosis/v12/osmoutils" + "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types" +) + +type Keeper struct { + storeKey sdk.StoreKey + paramSpace paramtypes.Subspace + stakingKeeper types.StakingInterface +} + +func NewKeeper(storeKey sdk.StoreKey, paramSpace paramtypes.Subspace, stakingKeeper types.StakingInterface) Keeper { + if !paramSpace.HasKeyTable() { + paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable()) + } + + return Keeper{ + storeKey: storeKey, + paramSpace: paramSpace, + stakingKeeper: stakingKeeper, + } +} + +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName)) +} + +func (k Keeper) SetValidatorSetPreferences(ctx sdk.Context, delegator string, validators types.ValidatorSetPreferences) { + store := ctx.KVStore(k.storeKey) + osmoutils.MustSet(store, []byte(delegator), &validators) +} + +func (k Keeper) GetValidatorSetPreference(ctx sdk.Context, delegator string) (types.ValidatorSetPreferences, bool) { + validatorSet := types.ValidatorSetPreferences{} + + store := ctx.KVStore(k.storeKey) + b := store.Get([]byte(delegator)) + if b == nil { + return types.ValidatorSetPreferences{}, false + } + + err := proto.Unmarshal(b, &validatorSet) + if err != nil { + return types.ValidatorSetPreferences{}, false + } + + return validatorSet, true +} diff --git a/x/validator-preference/keeper/keeper_test.go b/x/validator-preference/keeper/keeper_test.go new file mode 100644 index 00000000000..dc707d7bca8 --- /dev/null +++ b/x/validator-preference/keeper/keeper_test.go @@ -0,0 +1,67 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/osmosis-labs/osmosis/v12/app/apptesting" + "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types" + "github.com/stretchr/testify/suite" +) + +type KeeperTestSuite struct { + apptesting.KeeperTestHelper + + cleanup func() +} + +func (suite *KeeperTestSuite) SetupTest() { + suite.Setup() +} + +func (suite *KeeperTestSuite) Cleanup() { + suite.cleanup() +} + +func (suite *KeeperTestSuite) SetupValidators(bondStatuses []stakingtypes.BondStatus) []sdk.ValAddress { + valAddrs := []sdk.ValAddress{} + for _, status := range bondStatuses { + valAddr := suite.SetupValidator(status) + valAddrs = append(valAddrs, valAddr) + } + return valAddrs +} + +// SetupMultipleValidators setups "numValidator" validators and returns their address in string +func (suite *KeeperTestSuite) SetupMultipleValidators(numValidator int) []string { + valAddrs := []string{} + for i := 0; i < numValidator; i++ { + valAddr := suite.SetupValidators([]stakingtypes.BondStatus{stakingtypes.Bonded}) + valAddrs = append(valAddrs, valAddr[0].String()) + } + return valAddrs +} + +func (suite *KeeperTestSuite) PrepareDelegateToValidatorSet() []types.ValidatorPreference { + valAddrs := suite.SetupMultipleValidators(3) + valPreferences := []types.ValidatorPreference{ + { + ValOperAddress: valAddrs[0], + Weight: sdk.NewDecWithPrec(5, 1), + }, + { + ValOperAddress: valAddrs[1], + Weight: sdk.NewDecWithPrec(3, 1), + }, + { + ValOperAddress: valAddrs[2], + Weight: sdk.NewDecWithPrec(2, 1), + }, + } + return valPreferences +} + +func TestKeeperTestSuite(t *testing.T) { + suite.Run(t, new(KeeperTestSuite)) +} diff --git a/x/validator-preference/keeper/msg_server.go b/x/validator-preference/keeper/msg_server.go new file mode 100644 index 00000000000..b6858c35c82 --- /dev/null +++ b/x/validator-preference/keeper/msg_server.go @@ -0,0 +1,60 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types" +) + +type msgServer struct { + keeper *Keeper +} + +// NewMsgServerImpl returns an implementation of the MsgServer interface +// for the provided Keeper. +func NewMsgServerImpl(keeper *Keeper) types.MsgServer { + return &msgServer{ + keeper: keeper, + } +} + +var _ types.MsgServer = msgServer{} + +func (server msgServer) SetValidatorSetPreference(goCtx context.Context, msg *types.MsgSetValidatorSetPreference) (*types.MsgSetValidatorSetPreferenceResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + preferences := msg.Preferences + + // check if a user already have a validator-set created + existingValidator, found := server.keeper.GetValidatorSetPreference(ctx, msg.Delegator) + if found { + preferences = existingValidator.Preferences + } + + // check if the distribution weights equals 1 + err := server.keeper.ValidatePreferences(ctx, preferences) + if err != nil { + return nil, err + } + + // update the validator-set based on what user provides + setMsg := types.ValidatorSetPreferences{ + Preferences: msg.Preferences, + } + + server.keeper.SetValidatorSetPreferences(ctx, msg.Delegator, setMsg) + return &types.MsgSetValidatorSetPreferenceResponse{}, nil +} + +func (server msgServer) DelegateToValidatorSet(goCtx context.Context, msg *types.MsgDelegateToValidatorSet) (*types.MsgDelegateToValidatorSetResponse, error) { + return &types.MsgDelegateToValidatorSetResponse{}, nil +} + +func (server msgServer) UndelegateFromValidatorSet(goCtx context.Context, msg *types.MsgUndelegateFromValidatorSet) (*types.MsgUndelegateFromValidatorSetResponse, error) { + return &types.MsgUndelegateFromValidatorSetResponse{}, nil +} + +func (server msgServer) WithdrawDelegationRewards(goCtx context.Context, msg *types.MsgWithdrawDelegationRewards) (*types.MsgWithdrawDelegationRewardsResponse, error) { + return &types.MsgWithdrawDelegationRewardsResponse{}, nil +} diff --git a/x/validator-preference/keeper/msg_server_test.go b/x/validator-preference/keeper/msg_server_test.go new file mode 100644 index 00000000000..6391d634477 --- /dev/null +++ b/x/validator-preference/keeper/msg_server_test.go @@ -0,0 +1,124 @@ +package keeper_test + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/osmosis-labs/osmosis/v12/x/validator-preference/keeper" + "github.com/osmosis-labs/osmosis/v12/x/validator-preference/types" +) + +func (suite *KeeperTestSuite) TestSetValidatorSetPreference() { + suite.SetupTest() + + // setup 3 validators + valAddrs := suite.SetupMultipleValidators(3) + + type param struct { + delegator sdk.AccAddress + preferences []types.ValidatorPreference + } + + tests := []struct { + name string + param param + expectPass bool + }{ + { + name: "creation of new validator set", + param: param{ + delegator: sdk.AccAddress([]byte("addr1---------------")), + preferences: []types.ValidatorPreference{ + { + ValOperAddress: valAddrs[0], + Weight: sdk.NewDecWithPrec(5, 1), + }, + { + ValOperAddress: valAddrs[1], + Weight: sdk.NewDecWithPrec(3, 1), + }, + { + ValOperAddress: valAddrs[2], + Weight: sdk.NewDecWithPrec(2, 1), + }, + }, + }, + expectPass: true, + }, + { + name: "Update existing validator set", + param: param{ + delegator: sdk.AccAddress([]byte("addr1---------------")), + preferences: []types.ValidatorPreference{ + { + ValOperAddress: valAddrs[0], + Weight: sdk.NewDecWithPrec(2, 1), + }, + { + ValOperAddress: valAddrs[1], + Weight: sdk.NewDecWithPrec(2, 1), + }, + { + ValOperAddress: valAddrs[2], + Weight: sdk.NewDecWithPrec(6, 1), + }, + }, + }, + expectPass: true, + }, + { + name: "create validator set with unknown validator address", + param: param{ + delegator: sdk.AccAddress([]byte("addr2---------------")), + preferences: []types.ValidatorPreference{ + { + ValOperAddress: "addr1---------------", + Weight: sdk.NewDec(1), + }, + { + ValOperAddress: valAddrs[1], + Weight: sdk.NewDecWithPrec(3, 1), + }, + }, + }, + expectPass: false, + }, + { + name: "create validator set with weights != 1", + param: param{ + delegator: sdk.AccAddress([]byte("addr3---------------")), + preferences: []types.ValidatorPreference{ + { + ValOperAddress: valAddrs[0], + Weight: sdk.NewDecWithPrec(5, 1), + }, + { + ValOperAddress: valAddrs[1], + Weight: sdk.NewDecWithPrec(3, 1), + }, + { + ValOperAddress: valAddrs[2], + Weight: sdk.NewDecWithPrec(3, 1), + }, + }, + }, + expectPass: false, + }, + } + + for _, test := range tests { + suite.Run(test.name, func() { + + // setup message server + msgServer := keeper.NewMsgServerImpl(suite.App.ValidatorPreferenceKeeper) + c := sdk.WrapSDKContext(suite.Ctx) + + // call the create validator set preference + _, err := msgServer.SetValidatorSetPreference(c, types.NewMsgSetValidatorSetPreference(test.param.delegator, test.param.preferences)) + if test.expectPass { + suite.Require().NoError(err) + } else { + suite.Require().Error(err) + } + + }) + } +} diff --git a/x/validator-preference/types/codec.go b/x/validator-preference/types/codec.go new file mode 100644 index 00000000000..8ce925b9881 --- /dev/null +++ b/x/validator-preference/types/codec.go @@ -0,0 +1,30 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +func RegisterCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgSetValidatorSetPreference{}, "", nil) + cdc.RegisterConcrete(&MsgDelegateToValidatorSet{}, "", nil) + cdc.RegisterConcrete(&MsgUndelegateFromValidatorSet{}, "", nil) + // this line is used by starport scaffolding # 2 +} + +func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgSetValidatorSetPreference{}, + &MsgDelegateToValidatorSet{}, + &MsgUndelegateFromValidatorSet{}, + ) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +var ( + Amino = codec.NewLegacyAmino() + ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry()) +) diff --git a/x/validator-preference/types/errors.go b/x/validator-preference/types/errors.go new file mode 100644 index 00000000000..ab1254f4c2b --- /dev/null +++ b/x/validator-preference/types/errors.go @@ -0,0 +1 @@ +package types diff --git a/x/validator-preference/types/expected_interfaces.go b/x/validator-preference/types/expected_interfaces.go new file mode 100644 index 00000000000..5e51e195ea0 --- /dev/null +++ b/x/validator-preference/types/expected_interfaces.go @@ -0,0 +1,17 @@ +package types + +import ( + "time" + + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// StakingKeeper expected staking keeper. +type StakingInterface interface { + GetAllValidators(ctx sdk.Context) (validators []stakingtypes.Validator) + GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool) + Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int, tokenSrc stakingtypes.BondStatus, validator stakingtypes.Validator, subtractAccount bool) (newShares sdk.Dec, err error) + GetDelegation(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (delegation stakingtypes.Delegation, found bool) + Undelegate(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec) (time.Time, error) +} diff --git a/x/validator-preference/types/keys.go b/x/validator-preference/types/keys.go new file mode 100644 index 00000000000..d606ffd3f31 --- /dev/null +++ b/x/validator-preference/types/keys.go @@ -0,0 +1,15 @@ +package types + +var ( + // ModuleName defines the module name + ModuleName = "validator-set-preference" + + // StoreKey defines the primary module store key + StoreKey = ModuleName + + // RouterKey is the message route for slashing. + RouterKey = ModuleName + + // KeyPrefixSuperfluidAsset defines prefix key for validator set. + KeyPrefixValidatorSet = []byte{0x01} +) diff --git a/x/validator-preference/types/msgs.go b/x/validator-preference/types/msgs.go new file mode 100644 index 00000000000..569c25f3aa8 --- /dev/null +++ b/x/validator-preference/types/msgs.go @@ -0,0 +1,84 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +// constants +const ( + TypeMsgSetValidatorSetPreference = "set_validator_set_preference" +) + +var _ sdk.Msg = &MsgSetValidatorSetPreference{} + +// NewMsgCreateValidatorSetPreference creates a msg to create a validator-set preference. +func NewMsgSetValidatorSetPreference(delegator sdk.AccAddress, preferences []ValidatorPreference) *MsgSetValidatorSetPreference { + return &MsgSetValidatorSetPreference{ + Delegator: delegator.String(), + Preferences: preferences, + } +} + +func (m MsgSetValidatorSetPreference) Route() string { return RouterKey } +func (m MsgSetValidatorSetPreference) Type() string { return TypeMsgSetValidatorSetPreference } +func (m MsgSetValidatorSetPreference) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(m.Delegator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid delegator address (%s)", err) + } + + for _, validator := range m.Preferences { + _, err := sdk.ValAddressFromBech32(validator.ValOperAddress) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid validator address (%s)", err) + } + } + + return nil +} + +func (m MsgSetValidatorSetPreference) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +// GetSigners takes a create validator-set message and returns the delegator in a byte array. +func (m MsgSetValidatorSetPreference) GetSigners() []sdk.AccAddress { + delegator, _ := sdk.AccAddressFromBech32(m.Delegator) + return []sdk.AccAddress{delegator} +} + +// constants +const ( + TypeMsgDelegateToValidatorSet = "delegate_to_validator_set" +) + +var _ sdk.Msg = &MsgDelegateToValidatorSet{} + +// NewMsgMsgStakeToValidatorSet creates a msg to stake to a validator. +func NewMsgMsgStakeToValidatorSet(delegator sdk.AccAddress, coin sdk.Coin) *MsgDelegateToValidatorSet { + return &MsgDelegateToValidatorSet{ + Delegator: delegator.String(), + Coin: coin, + } +} + +func (m MsgDelegateToValidatorSet) Route() string { return RouterKey } +func (m MsgDelegateToValidatorSet) Type() string { return TypeMsgDelegateToValidatorSet } +func (m MsgDelegateToValidatorSet) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(m.Delegator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err) + } + + return nil +} + +func (m MsgDelegateToValidatorSet) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m)) +} + +func (m MsgDelegateToValidatorSet) GetSigners() []sdk.AccAddress { + delegator, _ := sdk.AccAddressFromBech32(m.Delegator) + return []sdk.AccAddress{delegator} +} diff --git a/x/validator-preference/types/params.go b/x/validator-preference/types/params.go new file mode 100644 index 00000000000..4f3215e3504 --- /dev/null +++ b/x/validator-preference/types/params.go @@ -0,0 +1,32 @@ +package types + +import ( + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +var _ paramtypes.ParamSet = (*Params)(nil) + +// ParamKeyTable the param key table for launch module +func ParamKeyTable() paramtypes.KeyTable { + return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) +} + +// NewParams creates a new Params instance +func NewParams() Params { + return Params{} +} + +// DefaultParams returns a default set of parameters +func DefaultParams() Params { + return NewParams() +} + +// ParamSetPairs get the params.ParamSet +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{} +} + +// Validate validates the set of params +func (p Params) Validate() error { + return nil +} diff --git a/x/validator-preference/types/params.pb.go b/x/validator-preference/types/params.pb.go new file mode 100644 index 00000000000..139de3145b5 --- /dev/null +++ b/x/validator-preference/types/params.pb.go @@ -0,0 +1,335 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: osmosis/validator-preference/v1beta1/params.proto + +package types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// Params defines the parameters for the module. +type Params struct { + // the users validator-set, {valAddr, weight} to unstake the tokens from. + Preferences []ValidatorPreference `protobuf:"bytes,1,rep,name=preferences,proto3" json:"preferences" yaml:"preferences"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_db06f71db3b2b0f5, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetPreferences() []ValidatorPreference { + if m != nil { + return m.Preferences + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "osmosis.validatorpreference.v1beta1.Params") +} + +func init() { + proto.RegisterFile("osmosis/validator-preference/v1beta1/params.proto", fileDescriptor_db06f71db3b2b0f5) +} + +var fileDescriptor_db06f71db3b2b0f5 = []byte{ + // 236 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0xcc, 0x2f, 0xce, 0xcd, + 0x2f, 0xce, 0x2c, 0xd6, 0x2f, 0x4b, 0xcc, 0xc9, 0x4c, 0x49, 0x2c, 0xc9, 0x2f, 0xd2, 0x2d, 0x28, + 0x4a, 0x4d, 0x4b, 0x2d, 0x4a, 0xcd, 0x4b, 0x4e, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, + 0xd4, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x86, + 0x6a, 0xd1, 0x83, 0x6b, 0x41, 0xe8, 0xd0, 0x83, 0xea, 0x90, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, + 0xab, 0xd7, 0x07, 0xb1, 0x20, 0x5a, 0xa5, 0x0c, 0x88, 0xb2, 0xad, 0xb8, 0x24, 0xb1, 0x24, 0x15, + 0xa2, 0x43, 0xa9, 0x81, 0x91, 0x8b, 0x2d, 0x00, 0x6c, 0xbb, 0x50, 0x19, 0x17, 0x37, 0x42, 0x71, + 0xb1, 0x04, 0xa3, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x85, 0x1e, 0x11, 0xae, 0xd1, 0x0b, 0x83, 0xc9, + 0x05, 0xc0, 0xe5, 0x9c, 0xa4, 0x4e, 0xdc, 0x93, 0x67, 0xf8, 0x74, 0x4f, 0x5e, 0xa8, 0x32, 0x31, + 0x37, 0xc7, 0x4a, 0x09, 0xc9, 0x68, 0xa5, 0x20, 0x64, 0x8b, 0x9c, 0xa2, 0x4e, 0x3c, 0x92, 0x63, + 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, + 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, 0x21, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, + 0x3f, 0x57, 0x1f, 0xea, 0x0c, 0xdd, 0x9c, 0xc4, 0xa4, 0x62, 0x7d, 0xb8, 0x37, 0x0d, 0x8d, 0xf4, + 0x2b, 0xb0, 0x7b, 0xb6, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0xec, 0x4b, 0x63, 0x40, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x11, 0x17, 0x30, 0x4e, 0x87, 0x01, 0x00, 0x00, +} + +func (m *Params) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Preferences) > 0 { + for iNdEx := len(m.Preferences) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Preferences[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintParams(dAtA []byte, offset int, v uint64) int { + offset -= sovParams(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Preferences) > 0 { + for _, e := range m.Preferences { + l = e.Size() + n += 1 + l + sovParams(uint64(l)) + } + } + return n +} + +func sovParams(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozParams(x uint64) (n int) { + return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Preferences", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Preferences = append(m.Preferences, ValidatorPreference{}) + if err := m.Preferences[len(m.Preferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipParams(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthParams + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupParams + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthParams + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/validator-preference/valpref-module/module.go b/x/validator-preference/valpref-module/module.go new file mode 100644 index 00000000000..768fc5b21aa --- /dev/null +++ b/x/validator-preference/valpref-module/module.go @@ -0,0 +1,212 @@ +package validator_preference + +import ( + "encoding/json" + "fmt" + "math/rand" + + "github.com/gorilla/mux" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/osmosis-labs/osmosis/v11/x/gamm/keeper" + "github.com/osmosis-labs/osmosis/v11/x/superfluid/types" + "github.com/spf13/cobra" + abci "github.com/tendermint/tendermint/abci/types" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} +) + +// ---------------------------------------------------------------------------- +// AppModuleBasic +// ---------------------------------------------------------------------------- + +// AppModuleBasic implements the AppModuleBasic interface for the capability module. +type AppModuleBasic struct { + cdc codec.Codec +} + +func NewAppModuleBasic(cdc codec.Codec) AppModuleBasic { + return AppModuleBasic{cdc: cdc} +} + +// Name returns the capability module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +func (AppModuleBasic) RegisterCodec(cdc *codec.LegacyAmino) { + types.RegisterCodec(cdc) +} + +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + types.RegisterCodec(cdc) +} + +// RegisterInterfaces registers the module's interface types. +func (a AppModuleBasic) RegisterInterfaces(reg cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(reg) +} + +// DefaultGenesis returns the capability module's default genesis state. +// TODO: Implement +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return json.RawMessage{} + // return cdc.MustMarshalJSON(types.DefaultGenesis()) +} + +// ValidateGenesis performs genesis state validation for the capability module. +// TODO: Implement +func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error { + // var genState types.GenesisState + // if err := cdc.UnmarshalJSON(bz, &genState); err != nil { + // return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + // } + // return genState.Validate() + return nil +} + +// RegisterRESTRoutes registers the capability module's REST service handlers. +func (AppModuleBasic) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Router) { +} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module. +func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) { +} + +// GetTxCmd returns the capability module's root tx command. +func (a AppModuleBasic) GetTxCmd() *cobra.Command { + return nil +} + +// GetQueryCmd returns the capability module's root query command. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return nil +} + +// ---------------------------------------------------------------------------- +// AppModule +// ---------------------------------------------------------------------------- + +// AppModule implements the AppModule interface for the capability module. +type AppModule struct { + AppModuleBasic + + keeper keeper.Keeper + accountKeeper stakingtypes.AccountKeeper + bankKeeper stakingtypes.BankKeeper + gammKeeper types.GammKeeper +} + +func NewAppModule(cdc codec.Codec, keeper keeper.Keeper, + accountKeeper stakingtypes.AccountKeeper, bankKeeper stakingtypes.BankKeeper, + gammKeeper types.GammKeeper, +) AppModule { + return AppModule{ + AppModuleBasic: NewAppModuleBasic(cdc), + keeper: keeper, + + accountKeeper: accountKeeper, + bankKeeper: bankKeeper, + gammKeeper: gammKeeper, + } +} + +// Name returns the capability module's name. +func (am AppModule) Name() string { + return am.AppModuleBasic.Name() +} + +// Route returns the capability module's message routing key. +func (am AppModule) Route() sdk.Route { + return sdk.Route{} +} + +// QuerierRoute returns the capability module's query routing key. +func (AppModule) QuerierRoute() string { return types.QuerierRoute } + +// LegacyQuerierHandler returns the x/superfluid module's Querier. +func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier { + return func(sdk.Context, []string, abci.RequestQuery) ([]byte, error) { + return nil, fmt.Errorf("legacy querier not supported for the x/%s module", types.ModuleName) + } +} + +// RegisterServices registers module services. +func (am AppModule) RegisterServices(cfg module.Configurator) { +} + +// RegisterInvariants registers the capability module's invariants. +func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) { +} + +// InitGenesis performs the capability module's genesis initialization It returns +// no validator updates. +// TODO: Implement +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, gs json.RawMessage) []abci.ValidatorUpdate { + // var genState types.GenesisState + // // Initialize global index to index in genesis state + // cdc.MustUnmarshalJSON(gs, &genState) + + // // InitGenesis(ctx, am.keeper, genState) + + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the capability module's exported genesis state as raw JSON bytes. +// TODO: Come back and fix this +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + // var genState types.GenesisState + // return cdc.MustMarshalJSON(genState) + return json.RawMessage{} +} + +// BeginBlock executes all ABCI BeginBlock logic respective to the capability module. +func (am AppModule) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {} + +// EndBlock executes all ABCI EndBlock logic respective to the capability module. It +// returns no validator updates. +func (am AppModule) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate { + return []abci.ValidatorUpdate{} +} + +// ___________________________________________________________________________ + +// AppModuleSimulation functions + +// GenerateGenesisState creates a randomized GenState of the pool-incentives module. +func (AppModule) GenerateGenesisState(simState *module.SimulationState) { +} + +// ProposalContents doesn't return any content functions for governance proposals. +func (am AppModule) ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent { + return []simtypes.WeightedProposalContent{} +} + +// RandomizedParams creates randomized pool-incentives param changes for the simulator. +func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange { + return nil // TODO +} + +// RegisterStoreDecoder registers a decoder for supply module's types. +func (am AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry) { + // TODO +} + +// WeightedOperations returns the all the module operations with their respective weights. +func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation { + return []simtypes.WeightedOperation{} +} + +func (am AppModule) ConsensusVersion() uint64 { + return 1 +}