implement --offline flag

CHANGELOG.md

@@ -168,6 +168,9 @@ Buffers for state serialization instead of Amino.
 * (server) [\#5709](https://github.com/cosmos/cosmos-sdk/pull/5709) There are two new flags for pruning, `--pruning-keep-every` 
 and `--pruning-snapshot-every` as an alternative to `--pruning`. They allow to fine tune the strategy for pruning the state.
 * (crypto/keys) [\#5739](https://github.com/cosmos/cosmos-sdk/pull/5739) Print an error message if the password input failed.
+* (client) [\#5810](https://github.com/cosmos/cosmos-sdk/pull/5810) Added new `--offline` flag improving the user experience. This
+allow to use `--generate-only` to be called on those cases where it needs a connection but we don't need
+to broadcast.
 
 ## [v0.38.1] - 2020-02-11
 

client/context/context.go

@@ -43,6 +43,7 @@ type CLIContext struct {
 	UseLedger     bool
 	Simulate      bool
 	GenerateOnly  bool
+	Offline       bool
 	Indent        bool
 	SkipConfirm   bool
 
@@ -60,14 +61,14 @@ func NewCLIContextWithInputAndFrom(input io.Reader, from string) CLIContext {
 	var nodeURI string
 	var rpc rpcclient.Client
 
-	genOnly := viper.GetBool(flags.FlagGenerateOnly)
-	fromAddress, fromName, err := GetFromFields(input, from, genOnly)
+	offline := viper.GetBool(flags.FlagOffline)
+	fromAddress, fromName, err := GetFromFields(input, from, offline)
 	if err != nil {
 		fmt.Printf("failed to get from fields: %v\n", err)
 		os.Exit(1)
 	}
 
-	if !genOnly {
+	if !offline {
 		nodeURI = viper.GetString(flags.FlagNode)
 		if nodeURI != "" {
 			rpc, err = rpcclient.NewHTTP(nodeURI, "/websocket")
@@ -92,7 +93,8 @@ func NewCLIContextWithInputAndFrom(input io.Reader, from string) CLIContext {
 		UseLedger:     viper.GetBool(flags.FlagUseLedger),
 		BroadcastMode: viper.GetString(flags.FlagBroadcastMode),
 		Simulate:      viper.GetBool(flags.FlagDryRun),
-		GenerateOnly:  genOnly,
+		GenerateOnly:  viper.GetBool(flags.FlagGenerateOnly),
+		Offline:       offline,
 		FromAddress:   fromAddress,
 		FromName:      fromName,
 		Indent:        viper.GetBool(flags.FlagIndentResponse),
@@ -276,14 +278,14 @@ func (ctx CLIContext) PrintOutput(toPrint interface{}) error {
 }
 
 // GetFromFields returns a from account address and Keybase name given either
-// an address or key name. If genOnly is true, only a valid Bech32 cosmos
+// an address or key name. If offline is true, only a valid Bech32 cosmos
 // address is returned.
-func GetFromFields(input io.Reader, from string, genOnly bool) (sdk.AccAddress, string, error) {
+func GetFromFields(input io.Reader, from string, offline bool) (sdk.AccAddress, string, error) {
 	if from == "" {
 		return nil, "", nil
 	}
 
-	if genOnly {
+	if offline {
 		addr, err := sdk.AccAddressFromBech32(from)
 		if err != nil {
 			return nil, "", errors.Wrap(err, "must provide a valid Bech32 address for generate-only")

client/context/context_test.go

@@ -0,0 +1,28 @@
+package context
+
+import (
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+)
+
+func TestCLIContext_WithOffline(t *testing.T) {
+	viper.Set(flags.FlagOffline, true)
+	viper.Set(flags.FlagNode, "tcp://localhost:26657")
+
+	ctx := NewCLIContext()
+	require.True(t, ctx.Offline)
+	require.Nil(t, ctx.Client)
+
+	viper.Reset()
+
+	viper.Set(flags.FlagOffline, false)
+	viper.Set(flags.FlagNode, "tcp://localhost:26657")
+
+	ctx = NewCLIContext()
+	require.False(t, ctx.Offline)
+	require.NotNil(t, ctx.Client)
+}

client/flags/flags.go

@@ -57,6 +57,7 @@ const (
 	FlagBroadcastMode      = "broadcast-mode"
 	FlagDryRun             = "dry-run"
 	FlagGenerateOnly       = "generate-only"
+	FlagOffline            = "offline"
 	FlagIndentResponse     = "indent"
 	FlagListenAddr         = "laddr"
 	FlagMaxOpenConnections = "max-open"
@@ -114,7 +115,8 @@ func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 		c.Flags().StringP(FlagBroadcastMode, "b", BroadcastSync, "Transaction broadcasting mode (sync|async|block)")
 		c.Flags().Bool(FlagTrustNode, true, "Trust connected full node (don't verify proofs for responses)")
 		c.Flags().Bool(FlagDryRun, false, "ignore the --gas flag and perform a simulation of a transaction, but don't broadcast it")
-		c.Flags().Bool(FlagGenerateOnly, false, "Build an unsigned transaction and write it to STDOUT (when enabled, the local Keybase is not accessible and the node operates offline)")
+		c.Flags().Bool(FlagGenerateOnly, false, "Build an unsigned transaction and write it to STDOUT")
+		c.Flags().Bool(FlagOffline, false, "Offline mode. Do not query a full node")
 		c.Flags().BoolP(FlagSkipConfirmation, "y", false, "Skip tx broadcasting prompt confirmation")
 		c.Flags().String(FlagKeyringBackend, DefaultKeyringBackend, "Select keyring's backend (os|file|test)")
 

x/auth/client/cli/broadcast.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"errors"
 	"strings"
 
 	"github.com/spf13/cobra"
@@ -26,6 +27,11 @@ $ <appcli> tx broadcast ./mytxn.json
 		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) (err error) {
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			if cliCtx.Offline {
+				return errors.New("cannot broadcast tx with offline flag")
+			}
+
 			stdTx, err := client.ReadStdTxFromFile(cliCtx.Codec, args[0])
 			if err != nil {
 				return

x/auth/client/cli/broadcast_test.go

@@ -0,0 +1,23 @@
+package cli
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/spf13/viper"
+
+	"github.com/tendermint/go-amino"
+)
+
+func TestGetBroadcastCommand_CannotBePerformedWhenOfflineFlag(t *testing.T) {
+	codec := amino.NewCodec()
+	cmd := GetBroadcastCommand(codec)
+
+	viper.Set(flags.FlagOffline, true)
+
+	err := cmd.RunE(nil, []string{})
+	require.EqualError(t, err, "cannot broadcast tx with offline flag")
+}

x/auth/client/cli/tx_multisign.go

@@ -51,7 +51,6 @@ recommended to set such parameters manually.
 	}
 
 	cmd.Flags().Bool(flagSigOnly, false, "Print only the generated signature, then exit")
-	cmd.Flags().Bool(flagOffline, false, "Offline mode. Do not query a full node")
 	cmd.Flags().String(flagOutfile, "", "The document will be written to the given file instead of STDOUT")
 
 	// Add the flags here and return the command
@@ -85,7 +84,7 @@ func makeMultiSignCmd(cdc *codec.Codec) func(cmd *cobra.Command, args []string)
 		cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc)
 		txBldr := types.NewTxBuilderFromCLI(inBuf)
 
-		if !viper.GetBool(flagOffline) {
+		if !cliCtx.Offline {
 			accnum, seq, err := types.NewAccountRetriever(client.Codec, cliCtx).GetAccountNumberSequence(multisigInfo.GetAddress())
 			if err != nil {
 				return err

x/auth/client/cli/tx_sign.go

@@ -22,7 +22,6 @@ const (
 	flagMultisig     = "multisig"
 	flagAppend       = "append"
 	flagValidateSigs = "validate-signatures"
-	flagOffline      = "offline"
 	flagSigOnly      = "signature-only"
 	flagOutfile      = "output-document"
 )
@@ -71,12 +70,7 @@ be generated via the 'multisign' command.
 		"Print the addresses that must sign the transaction, those who have already signed it, and make sure that signatures are in the correct order",
 	)
 	cmd.Flags().Bool(flagSigOnly, false, "Print only the generated signature, then exit")
-	cmd.Flags().Bool(
-		flagOffline, false,
-		"Offline mode; Do not query a full node. --account and --sequence options would be required if offline is set",
-	)
 	cmd.Flags().String(flagOutfile, "", "The document will be written to the given file instead of STDOUT")
-
 	cmd = flags.PostCommands(cmd)[0]
 	cmd.MarkFlagRequired(flags.FlagFrom)
 
@@ -86,7 +80,7 @@ be generated via the 'multisign' command.
 func preSignCmd(cmd *cobra.Command, _ []string) {
 	// Conditionally mark the account and sequence numbers required as no RPC
 	// query will be done.
-	if viper.GetBool(flagOffline) {
+	if viper.GetBool(flags.FlagOffline) {
 		cmd.MarkFlagRequired(flags.FlagAccountNumber)
 		cmd.MarkFlagRequired(flags.FlagSequence)
 	}
@@ -100,12 +94,11 @@ func makeSignCmd(cdc *codec.Codec) func(cmd *cobra.Command, args []string) error
 		}
 
 		inBuf := bufio.NewReader(cmd.InOrStdin())
-		offline := viper.GetBool(flagOffline)
 		cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc)
 		txBldr := types.NewTxBuilderFromCLI(inBuf)
 
 		if viper.GetBool(flagValidateSigs) {
-			if !printAndValidateSigs(cliCtx, txBldr.ChainID(), stdTx, offline) {
+			if !printAndValidateSigs(cliCtx, txBldr.ChainID(), stdTx, cliCtx.Offline) {
 				return fmt.Errorf("signatures validation failed")
 			}
 
@@ -124,14 +117,13 @@ func makeSignCmd(cdc *codec.Codec) func(cmd *cobra.Command, args []string) error
 			if err != nil {
 				return err
 			}
-
 			newTx, err = client.SignStdTxWithSignerAddress(
-				txBldr, cliCtx, multisigAddr, cliCtx.GetFromName(), stdTx, offline,
+				txBldr, cliCtx, multisigAddr, cliCtx.GetFromName(), stdTx, cliCtx.Offline,
 			)
 			generateSignatureOnly = true
 		} else {
 			appendSig := viper.GetBool(flagAppend) && !generateSignatureOnly
-			newTx, err = client.SignStdTx(txBldr, cliCtx, cliCtx.GetFromName(), stdTx, appendSig, offline)
+			newTx, err = client.SignStdTx(txBldr, cliCtx, cliCtx.GetFromName(), stdTx, appendSig, cliCtx.Offline)
 		}
 
 		if err != nil {

x/auth/client/tx.go

@@ -327,8 +327,8 @@ func PrepareTxBuilder(txBldr authtypes.TxBuilder, cliCtx context.CLIContext) (au
 
 func buildUnsignedStdTxOffline(txBldr authtypes.TxBuilder, cliCtx context.CLIContext, msgs []sdk.Msg) (stdTx authtypes.StdTx, err error) {
 	if txBldr.SimulateAndExecute() {
-		if cliCtx.GenerateOnly {
-			return stdTx, errors.New("cannot estimate gas with generate-only")
+		if cliCtx.Offline {
+			return stdTx, errors.New("cannot estimate gas in offline mode")
 		}
 
 		txBldr, err = EnrichWithGas(txBldr, cliCtx, msgs)

x/distribution/client/cli/tx.go

@@ -150,8 +150,8 @@ $ %s tx distribution withdraw-all-rewards --from mykey
 
 			// The transaction cannot be generated offline since it requires a query
 			// to get all the validators.
-			if cliCtx.GenerateOnly {
-				return fmt.Errorf("command disabled with the provided flag: %s", flags.FlagGenerateOnly)
+			if cliCtx.Offline {
+				return fmt.Errorf("cannot generate tx in offline mode")
 			}
 
 			msgs, err := common.WithdrawAllDelegatorRewards(cliCtx, queryRoute, delAddr)