refactor!: kill basic manager (cosmos#19512)

CHANGELOG.md

@@ -56,6 +56,10 @@ Every module contains its own CHANGELOG.md. Please refer to the module you are i
 
 ### Improvements
 
+* (types) [#19512](https://github.com/cosmos/cosmos-sdk/pull/19512) The notion of basic manager does not exist anymore.
+    * The module manager now can do everything that the basic manager was doing.
+    * `AppModuleBasic` has been deprecated for extension interfaces. Modules can now implement `HasRegisterInterfaces`, `HasGRPCGateway` and `HasAminoCodec` when relevant.
+    * SDK modules now directly implement those extension interfaces on `AppModule` instead of `AppModuleBasic`.
 * (client/keys) [#18950](https://github.com/cosmos/cosmos-sdk/pull/18950) Improve `<appd> keys add`, `<appd> keys import` and `<appd> keys rename` by checking name validation.
 * (client/keys) [#18745](https://github.com/cosmos/cosmos-sdk/pull/18745) Improve `<appd> keys export` and `<appd> keys mnemonic` by adding --yes option to skip interactive confirmation.
 * (client/keys) [#18743](https://github.com/cosmos/cosmos-sdk/pull/18743) Improve `<appd> keys add -i` by hiding inputting of bip39 passphrase.
@@ -100,6 +104,10 @@ Every module contains its own CHANGELOG.md. Please refer to the module you are i
 
 ### API Breaking Changes
 
+* (types) [#19512](https://github.com/cosmos/cosmos-sdk/pull/19512) Remove basic manager and all related functions (`module.BasicManager`, `module.NewBasicManager`, `module.NewBasicManagerFromManager`, `NewGenesisOnlyAppModule`).
+    * The module manager now can do everything that the basic manager was doing.
+    * When using runtime, just inject the module manager when needed using your app config.
+    * All `AppModuleBasic` structs have been removed.
 * (x/consensus) [#19488](https://github.com/cosmos/cosmos-sdk/pull/19488) Consensus module creation takes `appmodule.Environment` instead of individual services.
 * (server) [#18303](https://github.com/cosmos/cosmos-sdk/pull/18303) `x/genutil` now handles the application export. `server.AddCommands` does not take an `AppExporter` but instead `genutilcli.Commands` does.
 * (x/gov/testutil) [#17986](https://github.com/cosmos/cosmos-sdk/pull/18036) `MsgDeposit` has been removed because of AutoCLI migration.

UPGRADING.md

@@ -10,11 +10,6 @@ Note, always read the **SimApp** section for more information on application wir
 In this section we describe the changes made in Cosmos SDK' SimApp.
 **These changes are directly applicable to your application wiring.**
 
-#### AnteHandlers
-
-The GasConsumptionDecorator and IncreaseSequenceDecorator have been merged with the SigVerificationDecorator, so you'll
-need to remove them both from your app.go code, they will yield to unresolvable symbols when compiling.
-
 #### Client (`root.go`)
 
 The `client` package has been refactored to make use of the address codecs (address, validator address, consensus address, etc.).
@@ -33,16 +28,32 @@ clientCtx = clientCtx.
 
 Refer to SimApp `root_v2.go` and `root.go` for an example with an app v2 and a legacy app.
 
-### Core
+#### Server (`app.go`)
 
-`appmodule.Environment` interface was introduced to fetch different services from the application. This can be used as an alternative to using `sdk.UnwrapContext(ctx)` to fetch the services. It needs to be passed into a module at instantiation. 
+##### Module Manager
 
-Circuit Breaker is used as an example. 
+The basic module manager has been deleted. It was not necessary anymore and was simplified to use the `module.Manager` directly.
+It can be removed from your `app.go`.
 
-```go
-app.CircuitKeeper = circuitkeeper.NewKeeper(runtime.NewEnvironment((keys[circuittypes.StoreKey])), appCodec, authtypes.NewModuleAddress(govtypes.ModuleName).String(), app.AuthKeeper.AddressCodec())
+For depinject users, it isn't necessary anymore to supply a `map[string]module.AppModuleBasic` for customizing the app module basic instantiation.
+The custom parameters (such as genutil message validator or gov proposal handler, or evidence handler) can directly be supplied.
+When requiring a module manager in `root.go`, inject `*module.Manager` using `depinject.Inject`. 
+
+For non depinject users, simply call `RegisterLegacyAminoCodec` and `RegisterInterfaces` on the module manager:
+
+```diff
+-app.BasicModuleManager = module.NewBasicManagerFromManager(...)
+-app.BasicModuleManager.RegisterLegacyAminoCodec(legacyAmino)
+-app.BasicModuleManager.RegisterInterfaces(interfaceRegistry)
++app.ModuleManager.RegisterLegacyAminoCodec(legacyAmino)
++app.ModuleManager.RegisterInterfaces(interfaceRegistry)
 ```
 
+##### AnteHandlers
+
+The `GasConsumptionDecorator` and `IncreaseSequenceDecorator` have been merged with the SigVerificationDecorator, so you'll
+need to remove them both from your app.go code, they will yield to unresolvable symbols when compiling.
+
 #### Unordered Transactions
 
 The Cosmos SDK now supports unordered transactions. This means that transactions
@@ -129,26 +140,35 @@ If you were depending on `cosmossdk.io/api/tendermint`, please use the buf gener
 
 #### `**all**`
 
-##### Params
+##### Core API
 
-Previous module migrations have been removed. It is required to migrate to v0.50 prior to upgrading to v0.51 for not missing any module migrations.
+Core API has been introduced for modules since v0.47. With the deprecation of `sdk.Context`, we strongly recommend to use the `cosmossdk.io/core/appmodule` interfaces for the modules. This will allow the modules to work out of the box with server/v2 and baseapp, as well as limit their dependencies on the SDK.
 
-##### Core API
+Additionally, the `appmodule.Environment` interface is introduced to fetch different services from the application.
+This should be used as an alternative to using `sdk.UnwrapContext(ctx)` to fetch the services.
+It needs to be passed into a module at instantiation. 
 
-Core API has been introduces for modules in v0.47. With the deprecation of `sdk.Context`, we strongly recommend to use the `cosmossdk.io/core/appmodule` interfaces for the modules. This will allow the modules to work out of the box with server/v2 and baseapp, as well as limit their dependencies on the SDK.
+`x/circuit` is used as an example.:
+
+```go
+app.CircuitKeeper = circuitkeeper.NewKeeper(runtime.NewEnvironment((keys[circuittypes.StoreKey])), appCodec, authtypes.NewModuleAddress(govtypes.ModuleName).String(), app.AuthKeeper.AddressCodec())
+```
 
 ##### Dependency Injection
 
 Previously `cosmossdk.io/core` held functions `Invoke`, `Provide` and `Register` were moved to `cosmossdk.io/depinject/appconfig`.
 All modules using dependency injection must update their imports.
 
+##### Params
+
+Previous module migrations have been removed. It is required to migrate to v0.50 prior to upgrading to v0.51 for not missing any module migrations.
+
 ##### Genesis Interface
 
 All genesis interfaces have been migrated to take context.Context instead of sdk.Context.
 
-```golang
-// InitGenesis performs genesis initialization for the authz module. It returns
-// no validator updates.
+```go
+// InitGenesis performs genesis initialization for the authz module.
 func (am AppModule) InitGenesis(ctx context.Context, cdc codec.JSONCodec, data json.RawMessage) {
 }
 

baseapp/msg_service_router.go

@@ -163,7 +163,7 @@ func (msr *MsgServiceRouter) registerMsgServiceHandler(sd *grpc.ServiceDesc, met
 		return fmt.Errorf(
 			"type_url %s has not been registered yet. "+
 				"Before calling RegisterService, you must register all interfaces by calling the `RegisterInterfaces` "+
-				"method on module.BasicManager. Each module should call `msgservice.RegisterMsgServiceDesc` inside its "+
+				"method on module.Manager. Each module should call `msgservice.RegisterMsgServiceDesc` inside its "+
 				"`RegisterInterfaces` method with the `_Msg_serviceDesc` generated by proto-gen",
 			requestTypeName,
 		)

client/grpc_query_test.go

@@ -39,7 +39,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	keys := storetypes.NewKVStoreKeys(countertypes.StoreKey)
 	cms := integration.CreateMultiStore(keys, logger)
 	s.ctx = sdk.NewContext(cms, true, logger)
-	cfg := moduletestutil.MakeTestEncodingConfig(counter.AppModuleBasic{})
+	cfg := moduletestutil.MakeTestEncodingConfig(counter.AppModule{})
 	s.cdc = cfg.Codec
 
 	queryHelper := baseapp.NewQueryServerTestHelper(s.ctx, cfg.InterfaceRegistry)

client/tx/aux_builder_test.go

@@ -32,7 +32,7 @@ var (
 )
 
 func TestAuxTxBuilder(t *testing.T) {
-	counterModule := counter.AppModuleBasic{}
+	counterModule := counter.AppModule{}
 	cdc := moduletestutil.MakeTestEncodingConfig(counterModule).Codec
 	reg := codectypes.NewInterfaceRegistry()
 

client/v2/autocli/common_test.go

@@ -51,7 +51,7 @@ func initFixture(t *testing.T) *fixture {
 	clientConn, err := grpc.Dial(listener.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	assert.NilError(t, err)
 
-	encodingConfig := moduletestutil.MakeTestEncodingConfig(bank.AppModuleBasic{})
+	encodingConfig := moduletestutil.MakeTestEncodingConfig(bank.AppModule{})
 	kr, err := sdkkeyring.New(sdk.KeyringServiceName(), sdkkeyring.BackendMemory, home, nil, encodingConfig.Codec)
 	assert.NilError(t, err)
 

client/v2/go.mod

@@ -174,7 +174,7 @@ require (
 replace github.com/cosmos/cosmos-sdk => ./../../
 
 replace (
-	cosmossdk.io/api => ../../api
+	cosmossdk.io/api => ./../../api
 	cosmossdk.io/core => ./../../core
 	cosmossdk.io/depinject => ./../../depinject
 	cosmossdk.io/x/accounts => ./../../x/accounts

docs/architecture/adr-020-protobuf-transaction-encoding.md

@@ -349,7 +349,7 @@ type TxBuilder interface {
 ```
 
 We then update `Context` to have new fields: `Codec`, `TxGenerator`,
-and `AccountRetriever`, and we update `AppModuleBasic.GetTxCmd` to take
+and `AccountRetriever`, and we update `AppModule.GetTxCmd` to take
 a `Context` which should have all of these fields pre-populated.
 
 Each client method should then use one of the `Init` methods to re-initialize

docs/architecture/adr-032-typed-events.md

@@ -261,7 +261,7 @@ func TxEmitter(ctx context.Context, cliCtx client.Context, ehs ...EventHandler)
 }
 
 // PublishChainTxEvents events using cmtclient. Waits on context shutdown signals to exit.
-func PublishChainTxEvents(ctx context.Context, client cmtclient.EventsClient, bus pubsub.Bus, mb module.BasicManager) (err error) {
+func PublishChainTxEvents(ctx context.Context, client cmtclient.EventsClient, bus pubsub.Bus) (err error) {
     // Subscribe to transaction events
     txch, err := client.Subscribe(ctx, "txevents", "tm.event='Tx'", 100)
     if err != nil {
@@ -289,12 +289,12 @@ func PublishChainTxEvents(ctx context.Context, client cmtclient.EventsClient, bu
                     if !evt.Result.IsOK() {
                         continue
                     }
-                    // range over events, parse them using the basic manager and
+                    // range over events and parse them
                     // send them to the pubsub bus
                     for _, abciEv := range events {
                         typedEvent, err := sdk.ParseTypedEvent(abciEv)
                         if err != nil {
-                            return er
+                            return err
                         }
                         if err := bus.Publish(typedEvent); err != nil {
                             bus.Close()

docs/architecture/adr-033-protobuf-inter-module-comm.md

@@ -264,7 +264,7 @@ type Configurator interface {
 
 The `ModuleKey` is passed to modules in the `RegisterService` method itself so that `RegisterServices` serves as a single
 entry point for configuring module services. This is intended to also have the side-effect of greatly reducing boilerplate in
-`app.go`. For now, `ModuleKey`s will be created based on `AppModuleBasic.Name()`, but a more flexible system may be
+`app.go`. For now, `ModuleKey`s will be created based on `AppModule.Name()`, but a more flexible system may be
 introduced in the future. The `ModuleManager` will handle creation of module accounts behind the scenes.
 
 Because modules do not get direct access to each other anymore, modules may have unfulfilled dependencies. To make sure
@@ -344,7 +344,7 @@ Other future improvements may include:
     * optimizes inter-module calls - for instance caching resolved methods after first invocation
 * combining `StoreKey`s and `ModuleKey`s into a single interface so that modules have a single OCAPs handle
 * code generation which makes inter-module communication more performant
-* decoupling `ModuleKey` creation from `AppModuleBasic.Name()` so that app's can override root module account names
+* decoupling `ModuleKey` creation from `AppModule.Name()` so that app's can override root module account names
 * inter-module hooks and plugins
 
 ## Alternatives

docs/architecture/adr-063-core-module-api.md

@@ -463,10 +463,10 @@ module manager and follow the Cosmos SDK's existing [0-based versioning](https:/
 versioning as well as runtime modularity, new officially supported runtime modules will be created under the
 `cosmossdk.io/runtime` prefix. For each supported consensus engine a semantically-versioned go module should be created
 with a runtime implementation for that consensus engine. For example:
-- `cosmossdk.io/runtime/comet`
-- `cosmossdk.io/runtime/comet/v2`
-- `cosmossdk.io/runtime/rollkit`
-- etc.
+* `cosmossdk.io/runtime/comet`
+* `cosmossdk.io/runtime/comet/v2`
+* `cosmossdk.io/runtime/rollkit`
+* etc.
 
 These runtime modules should attempt to be semantically versioned even if the underlying consensus engine is not. Also,
 because a runtime module is also a first class Cosmos SDK module, it should have a protobuf module config type.