package crisis import ( "encoding/json" "fmt" "time" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cast" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" modulev1 "cosmossdk.io/api/cosmos/crisis/module/v1" "cosmossdk.io/core/appmodule" "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/server" servertypes "github.com/cosmos/cosmos-sdk/server/types" store "github.com/cosmos/cosmos-sdk/store/types" "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/cosmos/cosmos-sdk/x/crisis/client/cli" "github.com/cosmos/cosmos-sdk/x/crisis/exported" "github.com/cosmos/cosmos-sdk/x/crisis/keeper" "github.com/cosmos/cosmos-sdk/x/crisis/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) // ConsensusVersion defines the current x/crisis module consensus version. const ConsensusVersion = 2 var ( _ module.EndBlockAppModule = AppModule{} _ module.AppModuleBasic = AppModuleBasic{} ) // Module init related flags const ( FlagSkipGenesisInvariants = "x-crisis-skip-assert-invariants" ) // AppModuleBasic defines the basic application module used by the crisis module. type AppModuleBasic struct{} // Name returns the crisis module's name. func (AppModuleBasic) Name() string { return types.ModuleName } // RegisterLegacyAminoCodec registers the crisis module's types on the given LegacyAmino codec. func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { types.RegisterLegacyAminoCodec(cdc) } // DefaultGenesis returns default genesis state as raw bytes for the crisis // module. func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { return cdc.MustMarshalJSON(types.DefaultGenesisState()) } // ValidateGenesis performs genesis state validation for the crisis module. func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error { var data types.GenesisState if err := cdc.UnmarshalJSON(bz, &data); err != nil { return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) } return types.ValidateGenesis(&data) } // RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the capability module. func (AppModuleBasic) RegisterGRPCGatewayRoutes(_ client.Context, _ *gwruntime.ServeMux) {} // GetTxCmd returns the root tx command for the crisis module. func (b AppModuleBasic) GetTxCmd() *cobra.Command { return cli.NewTxCmd() } // GetQueryCmd returns no root query command for the crisis module. func (AppModuleBasic) GetQueryCmd() *cobra.Command { return nil } // RegisterInterfaces registers interfaces and implementations of the crisis // module. func (AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry) { types.RegisterInterfaces(registry) } // AppModule implements an application module for the crisis module. type AppModule struct { AppModuleBasic // NOTE: We store a reference to the keeper here so that after a module // manager is created, the invariants can be properly registered and // executed. keeper *keeper.Keeper // legacySubspace is used solely for migration of x/params managed parameters legacySubspace exported.Subspace skipGenesisInvariants bool } // NewAppModule creates a new AppModule object. If initChainAssertInvariants is set, // we will call keeper.AssertInvariants during InitGenesis (it may take a significant time) // - which doesn't impact the chain security unless 66+% of validators have a wrongly // modified genesis file. func NewAppModule(keeper *keeper.Keeper, skipGenesisInvariants bool, ss exported.Subspace) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{}, keeper: keeper, legacySubspace: ss, skipGenesisInvariants: skipGenesisInvariants, } } // AddModuleInitFlags implements servertypes.ModuleInitFlags interface. func AddModuleInitFlags(startCmd *cobra.Command) { startCmd.Flags().Bool(FlagSkipGenesisInvariants, false, "Skip x/crisis invariants check on startup") } // Name returns the crisis module's name. func (AppModule) Name() string { return types.ModuleName } // RegisterInvariants performs a no-op. func (AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} // RegisterServices registers module services. func (am AppModule) RegisterServices(cfg module.Configurator) { types.RegisterMsgServer(cfg.MsgServer(), am.keeper) m := keeper.NewMigrator(am.keeper, am.legacySubspace) if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil { panic(fmt.Sprintf("failed to migrate x/%s from version 1 to 2: %v", types.ModuleName, err)) } } // InitGenesis performs genesis initialization for the crisis module. It returns // no validator updates. func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate { start := time.Now() var genesisState types.GenesisState cdc.MustUnmarshalJSON(data, &genesisState) telemetry.MeasureSince(start, "InitGenesis", "crisis", "unmarshal") am.keeper.InitGenesis(ctx, &genesisState) if !am.skipGenesisInvariants { am.keeper.AssertInvariants(ctx) } return []abci.ValidatorUpdate{} } // ExportGenesis returns the exported genesis state as raw bytes for the crisis // module. func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { gs := am.keeper.ExportGenesis(ctx) return cdc.MustMarshalJSON(gs) } // ConsensusVersion implements AppModule/ConsensusVersion. func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion } // EndBlock returns the end blocker for the crisis module. It returns no validator // updates. func (am AppModule) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate { EndBlocker(ctx, *am.keeper) return []abci.ValidatorUpdate{} } // New App Wiring Setup func init() { appmodule.Register( &modulev1.Module{}, appmodule.Provide(ProvideModuleBasic, ProvideModule), ) } type CrisisInputs struct { depinject.In ModuleKey depinject.OwnModuleKey Config *modulev1.Module Key *store.KVStoreKey Cdc codec.Codec AppOpts servertypes.AppOptions `optional:"true"` Authority map[string]sdk.AccAddress `optional:"true"` BankKeeper types.SupplyKeeper // LegacySubspace is used solely for migration of x/params managed parameters LegacySubspace exported.Subspace } type CrisisOutputs struct { depinject.Out Module runtime.AppModuleWrapper CrisisKeeper *keeper.Keeper } func ProvideModuleBasic() runtime.AppModuleBasicWrapper { return runtime.WrapAppModuleBasic(AppModuleBasic{}) } func ProvideModule(in CrisisInputs) CrisisOutputs { var invalidCheckPeriod uint if in.AppOpts != nil { invalidCheckPeriod = cast.ToUint(in.AppOpts.Get(server.FlagInvCheckPeriod)) } feeCollectorName := in.Config.FeeCollectorName if feeCollectorName == "" { feeCollectorName = authtypes.FeeCollectorName } authority, ok := in.Authority[depinject.ModuleKey(in.ModuleKey).Name()] if !ok { // default to governance authority if not provided authority = authtypes.NewModuleAddress(govtypes.ModuleName) } k := keeper.NewKeeper( in.Cdc, in.Key, invalidCheckPeriod, in.BankKeeper, feeCollectorName, authority.String(), ) var skipGenesisInvariants bool if in.AppOpts != nil { skipGenesisInvariants = cast.ToBool(in.AppOpts.Get(FlagSkipGenesisInvariants)) } m := NewAppModule(k, skipGenesisInvariants, in.LegacySubspace) return CrisisOutputs{CrisisKeeper: k, Module: runtime.WrapAppModule(m)} }