fix(simapp/v2): full AutoCLI support

client/v2/autocli/app.go

@@ -1,6 +1,7 @@
 package autocli
 
 import (
+	"github.com/cosmos/gogoproto/proto"
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/reflect/protoregistry"
@@ -9,20 +10,23 @@ import (
 	"cosmossdk.io/client/v2/autocli/flag"
 	"cosmossdk.io/core/appmodule"
 	"cosmossdk.io/depinject"
+	"cosmossdk.io/log"
+	"cosmossdk.io/x/tx/signing"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	sdkflags "github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/codec/types"
 )
 
-// AppOptions are autocli options for an app. These options can be built via depinject based on an app config. Ex:
+// Options are input options for an autocli enabled app. These options can be built via depinject based on an app config.
 // Ex:
 //
 //	var autoCliOpts autocli.AppOptions
 //	err := depinject.Inject(appConfig, &encodingConfig.InterfaceRegistry, &autoCliOpts)
 //
 // If depinject isn't used, options can be provided manually or extracted from modules and the address codec can be provided by the auth keeper.
 // One method for extracting autocli options is via the github.com/cosmos/cosmos-sdk/runtime/services.ExtractAutoCLIOptions function.
-type AppOptions struct {
+type Options struct {
 	depinject.In
 
 	// Modules are the AppModule implementations for the modules in the app.
@@ -38,6 +42,24 @@ type AppOptions struct {
 	ClientCtx client.Context
 }
 
+// AppOptions are the autocli options for an app.
+type AppOptions struct {
+	Modules       map[string]appmodule.AppModule
+	ModuleOptions map[string]*autocliv1.ModuleOptions
+	ClientCtx     client.Context
+
+	skipValidation bool
+}
+
+// ProvideAppOptions returns AppOptions with the provided Options.
+func ProvideAppOptions(options Options) AppOptions {
+	return AppOptions{
+		Modules:       options.Modules,
+		ModuleOptions: options.ModuleOptions,
+		ClientCtx:     options.ClientCtx,
+	}
+}
+
 // EnhanceRootCommand enhances the provided root command with autocli AppOptions,
 // only adding missing commands and doesn't override commands already
 // in the root command. This allows for the graceful integration of autocli with
@@ -73,8 +95,10 @@ func (appOptions AppOptions) EnhanceRootCommand(rootCmd *cobra.Command) error {
 }
 
 func (appOptions AppOptions) EnhanceRootCommandWithBuilder(rootCmd *cobra.Command, builder *Builder) error {
-	if err := builder.ValidateAndComplete(); err != nil {
-		return err
+	if !appOptions.skipValidation {
+		if err := builder.ValidateAndComplete(); err != nil {
+			return err
+		}
 	}
 
 	// extract any custom commands from modules
@@ -124,3 +148,49 @@ func (appOptions AppOptions) EnhanceRootCommandWithBuilder(rootCmd *cobra.Comman
 
 	return nil
 }
+
+// NewAppOptionsFromConfig returns AppOptions for an app based on the provided modulesConfig and moduleOptions.
+// It returns an AppOptions instance usable for CLI parsing but not execution. For an execution usable AppOptions
+// see ProvideAppOptions, which expects input to be filled by depinject.
+func NewAppOptionsFromConfig(
+	modulesConfig depinject.Config,
+	moduleOptions map[string]*autocliv1.ModuleOptions,
+) (AppOptions, error) {
+	interfaceRegistry, err := types.NewInterfaceRegistryWithOptions(types.InterfaceRegistryOptions{
+		ProtoFiles: proto.HybridResolver,
+		SigningOptions: signing.Options{
+			AddressCodec:          nopAddressCodec{},
+			ValidatorAddressCodec: nopAddressCodec{},
+		},
+	})
+	if err != nil {
+		return AppOptions{}, err
+	}
+	cfg := struct {
+		depinject.In
+		Modules map[string]appmodule.AppModule
+	}{
+		Modules: nil,
+	}
+	err = depinject.Inject(depinject.Configs(
+		modulesConfig,
+		depinject.Supply(
+			log.NewNopLogger(),
+		)), &cfg)
+	if err != nil {
+		return AppOptions{}, err
+	}
+
+	return AppOptions{
+		Modules:        cfg.Modules,
+		ClientCtx:      client.Context{InterfaceRegistry: interfaceRegistry},
+		ModuleOptions:  moduleOptions,
+		skipValidation: true,
+	}, nil
+}
+
+type nopAddressCodec struct{}
+
+func (nopAddressCodec) StringToBytes(_ string) ([]byte, error) { return nil, nil }
+
+func (nopAddressCodec) BytesToString(_ []byte) (string, error) { return "", nil }

client/v2/go.mod

@@ -26,7 +26,7 @@ require (
 	cosmossdk.io/collections v0.4.1-0.20241104084251-838f1557af0a // indirect
 	cosmossdk.io/core/testing v0.0.0-20240923163230-04da382a9f29 // indirect
 	cosmossdk.io/errors v1.0.1 // indirect
-	cosmossdk.io/log v1.4.1 // indirect
+	cosmossdk.io/log v1.4.1
 	cosmossdk.io/math v1.3.0
 	cosmossdk.io/schema v0.3.1-0.20241010135032-192601639cac // indirect
 	cosmossdk.io/store v1.1.1-0.20240418092142-896cdf1971bc // indirect

simapp/v2/app_di.go

@@ -4,6 +4,7 @@ import (
 	_ "embed"
 	"fmt"
 
+	"cosmossdk.io/client/v2/autocli"
 	"cosmossdk.io/core/registry"
 	"cosmossdk.io/core/server"
 	"cosmossdk.io/core/transaction"
@@ -58,6 +59,8 @@ func AppConfig() depinject.Config {
 			multisigdepinject.ProvideAccount,
 			basedepinject.ProvideAccount,
 			lockupdepinject.ProvideAllLockupAccounts,
+			// autocli
+			autocli.ProvideAppOptions,
 
 			// provide base account options
 			basedepinject.ProvideSecp256K1PubKey,

simapp/v2/simdv2/cmd/root_di.go

@@ -39,6 +39,20 @@ func NewRootCmd[T transaction.Tx](
 		return nil, err
 	}
 
+	nodeCmds := nodeservice.NewNodeCommands()
+	autoCLIModuleOpts := make(map[string]*autocliv1.ModuleOptions)
+	autoCLIModuleOpts[nodeCmds.Name()] = nodeCmds.AutoCLIOptions()
+	autoCliOpts, err := autocli.NewAppOptionsFromConfig(
+		depinject.Configs(simapp.AppConfig(), depinject.Supply(runtime.GlobalConfig{})),
+		autoCLIModuleOpts,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = autoCliOpts.EnhanceRootCommand(rootCommand); err != nil {
+		return nil, err
+	}
 	subCommand, configMap, logger, err := factory.ParseCommand(rootCommand, args)
 	if err != nil {
 		if errors.Is(err, pflag.ErrHelp) {
@@ -48,7 +62,6 @@ func NewRootCmd[T transaction.Tx](
 	}
 
 	var (
-		autoCliOpts     autocli.AppOptions
 		moduleManager   *runtime.MM[T]
 		clientCtx       client.Context
 		simApp          *simapp.SimApp[T]
@@ -93,9 +106,7 @@ func NewRootCmd[T transaction.Tx](
 	if err != nil {
 		return nil, err
 	}
-	nodeCmds := nodeservice.NewNodeCommands()
-	autoCliOpts.ModuleOptions = make(map[string]*autocliv1.ModuleOptions)
-	autoCliOpts.ModuleOptions[nodeCmds.Name()] = nodeCmds.AutoCLIOptions()
+	autoCliOpts.ModuleOptions = autoCLIModuleOpts
 	if err := autoCliOpts.EnhanceRootCommand(rootCommand); err != nil {
 		return nil, err
 	}