refactor(client/v2)!: remove client.Context

client/v2/autocli/app.go

@@ -3,19 +3,21 @@ package autocli
 import (
 	"github.com/cosmos/gogoproto/proto"
 	"github.com/spf13/cobra"
-	"google.golang.org/grpc"
 	"google.golang.org/protobuf/reflect/protoregistry"
 
 	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
+	apitxsigning "cosmossdk.io/api/cosmos/tx/signing/v1beta1"
 	"cosmossdk.io/client/v2/autocli/flag"
+	"cosmossdk.io/core/address"
 	"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"
 	"github.com/cosmos/cosmos-sdk/codec/types"
+	authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
 )
 
 // AppOptions are input options for an autocli enabled app. These options can be built via depinject based on an app config.
@@ -38,8 +40,15 @@ type AppOptions struct {
 	// module or need to be improved.
 	ModuleOptions map[string]*autocliv1.ModuleOptions `optional:"true"`
 
-	// ClientCtx contains the necessary information needed to execute the commands.
-	ClientCtx client.Context
+	AddressCodec          address.Codec                 // AddressCodec is used to encode/decode account addresses.
+	ValidatorAddressCodec address.ValidatorAddressCodec // ValidatorAddressCodec is used to encode/decode validator addresses.
+	ConsensusAddressCodec address.ConsensusAddressCodec // ConsensusAddressCodec is used to encode/decode consensus addresses.
+
+	// Cdc is the codec used for binary encoding/decoding of messages.
+	Cdc codec.Codec
+
+	// TxConfigOpts contains options for configuring transaction handling.
+	TxConfigOpts authtx.ConfigOptions
 
 	skipValidation bool
 }
@@ -63,19 +72,19 @@ func (appOptions AppOptions) EnhanceRootCommand(rootCmd *cobra.Command) error {
 	builder := &Builder{
 		Builder: flag.Builder{
 			TypeResolver:          protoregistry.GlobalTypes,
-			FileResolver:          appOptions.ClientCtx.InterfaceRegistry,
-			AddressCodec:          appOptions.ClientCtx.AddressCodec,
-			ValidatorAddressCodec: appOptions.ClientCtx.ValidatorAddressCodec,
-			ConsensusAddressCodec: appOptions.ClientCtx.ConsensusAddressCodec,
-		},
-		GetClientConn: func(cmd *cobra.Command) (grpc.ClientConnInterface, error) {
-			return client.GetClientQueryContext(cmd)
+			FileResolver:          appOptions.Cdc.InterfaceRegistry(),
+			AddressCodec:          appOptions.AddressCodec,
+			ValidatorAddressCodec: appOptions.ValidatorAddressCodec,
+			ConsensusAddressCodec: appOptions.ConsensusAddressCodec,
 		},
+		GetClientConn: getQueryClientConn(appOptions.Cdc, appOptions.Cdc.InterfaceRegistry()),
 		AddQueryConnFlags: func(c *cobra.Command) {
 			sdkflags.AddQueryFlagsToCmd(c)
 			sdkflags.AddKeyringFlags(c.Flags())
 		},
-		AddTxConnFlags: sdkflags.AddTxFlagsToCmd,
+		AddTxConnFlags:   sdkflags.AddTxFlagsToCmd,
+		Cdc:              appOptions.Cdc,
+		EnabledSignModes: []apitxsigning.SignMode{apitxsigning.SignMode_SIGN_MODE_DIRECT},
 	}
 
 	return appOptions.EnhanceRootCommandWithBuilder(rootCmd, builder)
@@ -170,9 +179,9 @@ func NewAppOptionsFromConfig(
 
 	return AppOptions{
 		Modules:        cfg.Modules,
-		ClientCtx:      client.Context{InterfaceRegistry: interfaceRegistry},
 		ModuleOptions:  moduleOptions,
 		skipValidation: true,
+		Cdc:            codec.NewProtoCodec(interfaceRegistry),
 	}, nil
 }
 

client/v2/autocli/builder.go

@@ -4,7 +4,10 @@ import (
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc"
 
+	apisigning "cosmossdk.io/api/cosmos/tx/signing/v1beta1"
 	"cosmossdk.io/client/v2/autocli/flag"
+
+	"github.com/cosmos/cosmos-sdk/codec"
 )
 
 // Builder manages options for building CLI commands.
@@ -19,6 +22,9 @@ type Builder struct {
 	// AddQueryConnFlags and AddTxConnFlags are functions that add flags to query and transaction commands
 	AddQueryConnFlags func(*cobra.Command)
 	AddTxConnFlags    func(*cobra.Command)
+
+	Cdc              codec.Codec
+	EnabledSignModes []apisigning.SignMode
 }
 
 // ValidateAndComplete the builder fields.

client/v2/autocli/common.go

@@ -1,18 +1,28 @@
 package autocli
 
 import (
+	"context"
+	"crypto/tls"
 	"fmt"
-	"strings"
+	"strconv"
 
 	"github.com/spf13/cobra"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	grpcinsecure "google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/protobuf/reflect/protoreflect"
-	"sigs.k8s.io/yaml"
 
 	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
+	"cosmossdk.io/client/v2/autocli/config"
+	clientcontext "cosmossdk.io/client/v2/autocli/context"
+	"cosmossdk.io/client/v2/autocli/keyring"
+	"cosmossdk.io/client/v2/autocli/print"
+	"cosmossdk.io/client/v2/broadcast/comet"
 	"cosmossdk.io/client/v2/internal/flags"
 	"cosmossdk.io/client/v2/internal/util"
 
-	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/types"
 )
 
 type cmdType int
@@ -62,8 +72,13 @@ func (b *Builder) buildMethodCommandCommon(descriptor protoreflect.MethodDescrip
 	}
 	cmd.Args = binder.CobraArgs
 
+	cmd.PreRunE = b.preRunE()
+
 	cmd.RunE = func(cmd *cobra.Command, args []string) error {
-		ctx = cmd.Context()
+		ctx, err = b.getContext(cmd)
+		if err != nil {
+			return err
+		}
 
 		input, err := binder.BuildMessage(args)
 		if err != nil {
@@ -228,27 +243,135 @@ func enhanceCustomCmd(builder *Builder, cmd *cobra.Command, cmdType cmdType, mod
 
 // outOrStdoutFormat formats the output based on the output flag and writes it to the command's output stream.
 func (b *Builder) outOrStdoutFormat(cmd *cobra.Command, out []byte) error {
-	clientCtx := client.Context{}
-	if v := cmd.Context().Value(client.ClientContextKey); v != nil {
-		clientCtx = *(v.(*client.Context))
-	}
-	flagSet := cmd.Flags()
-	if clientCtx.OutputFormat == "" || flagSet.Changed(flags.FlagOutput) {
-		output, _ := flagSet.GetString(flags.FlagOutput)
-		clientCtx = clientCtx.WithOutputFormat(output)
-	}
-
-	var err error
-	outputType := clientCtx.OutputFormat
-	// if the output type is text, convert the json to yaml
-	// if output type is json or nil, default to json
-	if outputType == flags.OutputFormatText {
-		out, err = yaml.JSONToYAML(out)
+	p, err := print.NewPrinter(cmd)
+	if err != nil {
+		return err
+	}
+	return p.PrintBytes(out)
+}
+
+// getContext creates and returns a new context.Context with a clientcontext.Context value.
+// It initializes a printer and, if necessary, a keyring based on command flags.
+func (b *Builder) getContext(cmd *cobra.Command) (context.Context, error) {
+	printer, err := print.NewPrinter(cmd)
+	if err != nil {
+		return nil, err
+	}
+
+	// if the command uses the keyring this must be set
+	var k keyring.Keyring
+	if cmd.Flags().Lookup("keyring-dir") != nil && cmd.Flags().Lookup("keyring-backend") != nil {
+		k, err = keyring.NewKeyringFromFlags(cmd.Flags(), b.AddressCodec, cmd.InOrStdin(), b.Cdc)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	clientCtx := clientcontext.Context{
+		Flags:                 cmd.Flags(),
+		AddressCodec:          b.AddressCodec,
+		ValidatorAddressCodec: b.ValidatorAddressCodec,
+		ConsensusAddressCodec: b.ConsensusAddressCodec,
+		Cdc:                   b.Cdc,
+		Printer:               printer,
+		Keyring:               k,
+		EnabledSignmodes:      b.EnabledSignModes,
+	}
+
+	return context.WithValue(cmd.Context(), clientcontext.ContextKey, clientCtx), nil
+}
+
+// preRunE returns a function that sets flags from the configuration before running a command.
+// It is used as a PreRunE hook for cobra commands to ensure flags are properly initialized
+// from the configuration before command execution.
+func (b *Builder) preRunE() func(cmd *cobra.Command, args []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		err := b.setFlagsFromConfig(cmd)
 		if err != nil {
 			return err
 		}
+
+		return nil
+	}
+}
+
+func (b *Builder) setFlagsFromConfig(cmd *cobra.Command) error {
+	conf, err := config.CreateClientConfigFromFlags(cmd.Flags())
+	if err != nil {
+		return err
+	}
+
+	if cmd.Flags().Lookup("chain-id") != nil && !cmd.Flags().Changed("chain-id") {
+		_ = cmd.Flags().Set("chain-id", conf.ChainID)
+	}
+
+	if cmd.Flags().Lookup("keyring-backend") != nil && !cmd.Flags().Changed("keyring-backend") {
+		_ = cmd.Flags().Set("keyring-backend", conf.KeyringBackend)
+	}
+
+	if cmd.Flags().Lookup("from") != nil && !cmd.Flags().Changed("from") {
+		_ = cmd.Flags().Set("from", conf.KeyringDefaultKeyName)
+	}
+
+	if cmd.Flags().Lookup("output") != nil && !cmd.Flags().Changed("output") {
+		_ = cmd.Flags().Set("output", conf.Output)
+	}
+
+	if cmd.Flags().Lookup("node") != nil && !cmd.Flags().Changed("node") {
+		_ = cmd.Flags().Set("node", conf.Node)
+	}
+
+	if cmd.Flags().Lookup("broadcast-mode") != nil && !cmd.Flags().Changed("broadcast-mode") {
+		_ = cmd.Flags().Set("broadcast-mode", conf.BroadcastMode)
+	}
+
+	if cmd.Flags().Lookup("grpc-addr") != nil && !cmd.Flags().Changed("grpc-addr") {
+		_ = cmd.Flags().Set("grpc-addr", conf.GRPC.Address)
+	}
+
+	if cmd.Flags().Lookup("grpc-insecure") != nil && !cmd.Flags().Changed("grpc-insecure") {
+		_ = cmd.Flags().Set("grpc-insecure", strconv.FormatBool(conf.GRPC.Insecure))
 	}
 
-	cmd.Println(strings.TrimSpace(string(out)))
 	return nil
 }
+
+// getQueryClientConn returns a function that creates a gRPC client connection based on command flags.
+// It handles the creation of secure or insecure connections and falls back to a CometBFT broadcaster
+// if no gRPC address is specified.
+func getQueryClientConn(cdc codec.Codec, ir types.InterfaceRegistry) func(cmd *cobra.Command) (grpc.ClientConnInterface, error) {
+	return func(cmd *cobra.Command) (grpc.ClientConnInterface, error) {
+		var err error
+		creds := grpcinsecure.NewCredentials()
+
+		insecure := true
+		if cmd.Flags().Lookup("grpc-insecure") != nil {
+			insecure, err = cmd.Flags().GetBool("grpc-insecure")
+			if err != nil {
+				return nil, err
+			}
+		}
+		if !insecure {
+			creds = credentials.NewTLS(&tls.Config{MinVersion: tls.VersionTLS12})
+		}
+
+		var addr string
+		if cmd.Flags().Lookup("grpc-addr") != nil {
+			addr, err = cmd.Flags().GetString("grpc-addr")
+			if err != nil {
+				return nil, err
+			}
+		}
+		if addr == "" {
+			// if grpc-addr has not been set, use the default clientConn
+			// TODO: default is comet
+			node, err := cmd.Flags().GetString("node")
+			if err != nil {
+				return nil, err
+			}
+			return comet.NewCometBFTBroadcaster(node, comet.BroadcastSync, cdc, ir)
+		}
+
+		return grpc.NewClient(addr, []grpc.DialOption{grpc.WithTransportCredentials(creds)}...)
+	}
+}

client/v2/autocli/common_test.go

@@ -32,6 +32,10 @@ type fixture struct {
 	conn      *testClientConn
 	b         *Builder
 	clientCtx client.Context
+
+	home     string
+	chainID  string
+	kBackend string
 }
 
 func initFixture(t *testing.T) *fixture {
@@ -85,17 +89,28 @@ func initFixture(t *testing.T) *fixture {
 			return conn, nil
 		},
 		AddQueryConnFlags: flags.AddQueryFlagsToCmd,
-		AddTxConnFlags:    flags.AddTxFlagsToCmd,
+		AddTxConnFlags:    addTxAndGlobalFlagsToCmd,
+		Cdc:               encodingConfig.Codec,
 	}
 	assert.NilError(t, b.ValidateAndComplete())
 
 	return &fixture{
 		conn:      conn,
 		b:         b,
 		clientCtx: clientCtx,
+
+		home:     home,
+		chainID:  "autocli-test",
+		kBackend: sdkkeyring.BackendMemory,
 	}
 }
 
+func addTxAndGlobalFlagsToCmd(cmd *cobra.Command) {
+	f := cmd.Flags()
+	f.String("home", "", "home directory")
+	flags.AddTxFlagsToCmd(cmd)
+}
+
 func runCmd(fixture *fixture, command func(moduleName string, f *fixture) (*cobra.Command, error), args ...string) (*bytes.Buffer, error) {
 	out := &bytes.Buffer{}
 	cmd, err := command("test", fixture)