Update auth cli commands

client/cmd.go

@@ -148,31 +148,47 @@ func ReadTxCommandFlags(clientCtx Context, flagSet *pflag.FlagSet) (Context, err
 		return clientCtx, err
 	}
 
-	genOnly, _ := flagSet.GetBool(flags.FlagGenerateOnly)
-	clientCtx = clientCtx.WithGenerateOnly(genOnly)
+	if flagSet.Changed(flags.FlagGenerateOnly) {
+		genOnly, _ := flagSet.GetBool(flags.FlagGenerateOnly)
+		clientCtx = clientCtx.WithGenerateOnly(genOnly)
 
-	dryRun, _ := flagSet.GetBool(flags.FlagDryRun)
-	clientCtx = clientCtx.WithSimulation(dryRun)
+	}
 
-	offline, _ := flagSet.GetBool(flags.FlagOffline)
-	clientCtx = clientCtx.WithOffline(offline)
+	if flagSet.Changed(flags.FlagDryRun) {
+		dryRun, _ := flagSet.GetBool(flags.FlagDryRun)
+		clientCtx = clientCtx.WithSimulation(dryRun)
+	}
 
-	useLedger, _ := flagSet.GetBool(flags.FlagUseLedger)
-	clientCtx = clientCtx.WithUseLedger(useLedger)
+	if flagSet.Changed(flags.FlagOffline) {
+		offline, _ := flagSet.GetBool(flags.FlagOffline)
+		clientCtx = clientCtx.WithOffline(offline)
+	}
 
-	bMode, _ := flagSet.GetString(flags.FlagBroadcastMode)
-	clientCtx = clientCtx.WithBroadcastMode(bMode)
+	if flagSet.Changed(flags.FlagUseLedger) {
+		useLedger, _ := flagSet.GetBool(flags.FlagUseLedger)
+		clientCtx = clientCtx.WithUseLedger(useLedger)
+	}
 
-	skipConfirm, _ := flagSet.GetBool(flags.FlagSkipConfirmation)
-	clientCtx = clientCtx.WithSkipConfirmation(skipConfirm)
+	if flagSet.Changed(flags.FlagBroadcastMode) {
+		bMode, _ := flagSet.GetString(flags.FlagBroadcastMode)
+		clientCtx = clientCtx.WithBroadcastMode(bMode)
+	}
+
+	if flagSet.Changed(flags.FlagSkipConfirmation) {
+		skipConfirm, _ := flagSet.GetBool(flags.FlagSkipConfirmation)
+		clientCtx = clientCtx.WithSkipConfirmation(skipConfirm)
 
-	from, _ := flagSet.GetString(flags.FlagFrom)
-	fromAddr, fromName, err := GetFromFields(clientCtx.Keyring, from, clientCtx.GenerateOnly)
-	if err != nil {
-		return clientCtx, err
 	}
 
-	clientCtx = clientCtx.WithFrom(from).WithFromAddress(fromAddr).WithFromName(fromName)
+	if flagSet.Changed(flags.FlagFrom) {
+		from, _ := flagSet.GetString(flags.FlagFrom)
+		fromAddr, fromName, err := GetFromFields(clientCtx.Keyring, from, clientCtx.GenerateOnly)
+		if err != nil {
+			return clientCtx, err
+		}
+
+		clientCtx = clientCtx.WithFrom(from).WithFromAddress(fromAddr).WithFromName(fromName)
+	}
 
 	return clientCtx, nil
 }

client/context.go

@@ -195,6 +195,17 @@ func (ctx Context) WithInterfaceRegistry(interfaceRegistry codectypes.InterfaceR
 	return ctx
 }
 
+// PrintString prints the raw string to ctx.Output or os.Stdout
+func (ctx Context) PrintString(str string) error {
+	writer := ctx.Output
+	if writer == nil {
+		writer = os.Stdout
+	}
+
+	_, err := writer.Write([]byte(str))
+	return err
+}
+
 // PrintOutput outputs toPrint to the ctx.Output based on ctx.OutputFormat which is
 // either text or json. If text, toPrint will be YAML encoded. Otherwise, toPrint
 // will be JSON encoded using ctx.JSONMarshaler. An error is returned upon failure.

client/tx/factory.go

@@ -172,3 +172,14 @@ func (f Factory) WithSimulateAndExecute(sim bool) Factory {
 	f.simulateAndExecute = sim
 	return f
 }
+
+// SignMode returns the sign mode configured in the Factory
+func (f Factory) SignMode() signing.SignMode {
+	return f.signMode
+}
+
+// WithSignMode returns a copy of the Factory with an updated sign mode value.
+func (f Factory) WithSignMode(mode signing.SignMode) Factory {
+	f.signMode = mode
+	return f
+}

client/tx/tx.go

@@ -63,7 +63,12 @@ func GenerateTx(clientCtx client.Context, txf Factory, msgs ...sdk.Msg) error {
 		return err
 	}
 
-	return clientCtx.PrintOutput(tx.GetTx())
+	json, err := clientCtx.TxConfig.TxJSONEncoder()(tx.GetTx())
+	if err != nil {
+		return err
+	}
+
+	return clientCtx.PrintString(fmt.Sprintf("%s\n", json))
 }
 
 // BroadcastTx attempts to generate, sign and broadcast a transaction with the

client/tx_generator.go

@@ -14,6 +14,8 @@ type (
 		TxDecoder() sdk.TxDecoder
 		TxJSONEncoder() sdk.TxEncoder
 		TxJSONDecoder() sdk.TxDecoder
+		MarshalSignatureJSON([]signingtypes.SignatureV2) ([]byte, error)
+		UnmarshalSignatureJSON([]byte) ([]signingtypes.SignatureV2, error)
 	}
 
 	// TxConfig defines an interface a client can utilize to generate an

codec/proto_codec.go

@@ -17,7 +17,9 @@ type ProtoCodec struct {
 	anyUnpacker types.AnyUnpacker
 }
 
-func NewProtoCodec(anyUnpacker types.AnyUnpacker) Marshaler {
+var _ Marshaler = &ProtoCodec{}
+
+func NewProtoCodec(anyUnpacker types.AnyUnpacker) *ProtoCodec {
 	return &ProtoCodec{anyUnpacker: anyUnpacker}
 }
 

crypto/types/multisig/pubkey.go

@@ -17,6 +17,9 @@ type PubKey interface {
 
 	// GetPubKeys returns the crypto.PubKey's nested within the multi-sig PubKey
 	GetPubKeys() []crypto.PubKey
+
+	// GetThreshold returns the threshold number of signatures that must be obtained to verify a signature.
+	GetThreshold() uint
 }
 
 // GetSignBytesFunc defines a function type which returns sign bytes for a given SignMode or an error.

crypto/types/multisig/threshold_pubkey.go

@@ -154,3 +154,8 @@ func (pk PubKeyMultisigThreshold) Equals(other crypto.PubKey) bool {
 	}
 	return true
 }
+
+// GetThreshold implements the PubKey.GetThreshold method
+func (pk PubKeyMultisigThreshold) GetThreshold() uint {
+	return pk.K
+}

proto/cosmos/tx/signing/signing.proto

@@ -1,6 +1,8 @@
 syntax = "proto3";
 package cosmos.tx.signing;
 
+import "cosmos/crypto/crypto.proto";
+
 option go_package = "github.com/cosmos/cosmos-sdk/types/tx/signing";
 
 // SignMode represents a signing mode with its own security guarantees
@@ -20,3 +22,49 @@ enum SignMode {
     // Amino JSON and will be removed in the future
     SIGN_MODE_LEGACY_AMINO_JSON = 127;
 }
+
+// SignatureDescriptors wraps multiple SignatureDescriptor's.
+message SignatureDescriptors {
+    // signatures are the signature descriptors
+    repeated SignatureDescriptor signatures = 1;
+}
+
+// SignatureDescriptor is a convenience type which represents the full data for a
+// signature including the public key of the signer, signing modes and the signature
+// itself. It is primarily used for coordinating signatures between clients.
+message SignatureDescriptor {
+    // public_key is the public key of the signer
+    cosmos.crypto.PublicKey public_key = 1;
+
+    Data data = 2;
+
+    // Data represents signature data
+    message Data {
+        // sum is the oneof that specifies whether this represents single or multi-signature data
+        oneof sum {
+            // single represents a single signer
+            Single single = 1;
+
+            // multi represents a multisig signer
+            Multi multi = 2;
+        }
+
+        // Single is the signature data for a single signer
+        message Single {
+            // mode is the signing mode of the single signer
+            cosmos.tx.signing.SignMode mode = 1;
+
+            // signature is the raw signature bytes
+            bytes signature = 2;
+        }
+
+        // Multi is the signature data for a multisig public key
+        message Multi {
+            // bitarray specifies which keys within the multisig are signing
+            cosmos.crypto.CompactBitArray bitarray = 1;
+
+            // signatures is the signatures of the multi-signature
+            repeated Data signatures  = 2;
+        }
+    }
+}

simapp/params/proto.go

@@ -12,15 +12,15 @@ import (
 
 // MakeEncodingConfig creates an EncodingConfig for an amino based test configuration.
 func MakeEncodingConfig() EncodingConfig {
-	cdc := codec.New()
+	amino := codec.New()
 	interfaceRegistry := types.NewInterfaceRegistry()
-	marshaler := codec.NewHybridCodec(cdc, interfaceRegistry)
-	txGen := tx.NewTxConfig(interfaceRegistry, std.DefaultPublicKeyCodec{}, tx.DefaultSignModeHandler())
+	marshaler := codec.NewHybridCodec(amino, interfaceRegistry)
+	txGen := tx.NewTxConfig(codec.NewProtoCodec(interfaceRegistry), std.DefaultPublicKeyCodec{}, tx.DefaultSignModeHandler())
 
 	return EncodingConfig{
 		InterfaceRegistry: interfaceRegistry,
 		Marshaler:         marshaler,
 		TxConfig:          txGen,
-		Amino:             cdc,
+		Amino:             amino,
 	}
 }

testutil/network/network.go

@@ -13,8 +13,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/cosmos/cosmos-sdk/client/tx"
-
 	"github.com/stretchr/testify/require"
 	tmcfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
@@ -29,6 +27,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/client"
 	clientkeys "github.com/cosmos/cosmos-sdk/client/keys"
+	"github.com/cosmos/cosmos-sdk/client/tx"
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/cosmos/cosmos-sdk/server"

types/tx/signing/signature.go

@@ -1,6 +1,10 @@
 package signing
 
-import "github.com/tendermint/tendermint/crypto"
+import (
+	"fmt"
+
+	"github.com/tendermint/tendermint/crypto"
+)
 
 // SignatureV2 is a convenience type that is easier to use in application logic
 // than the protobuf SignerInfo's and raw signature bytes. It goes beyond the
@@ -15,3 +19,64 @@ type SignatureV2 struct {
 	// the signatures themselves for either single or multi-signatures.
 	Data SignatureData
 }
+
+// SignatureDataToSignatureDescriptorData converts a SignatureData to SignatureDescriptor_Data.
+// SignatureDescriptor_Data is considered an encoding type whereas SignatureData is used for
+// business logic.
+func SignatureDataToSignatureDescriptorData(data SignatureData) *SignatureDescriptor_Data {
+	switch data := data.(type) {
+	case *SingleSignatureData:
+		return &SignatureDescriptor_Data{
+			Sum: &SignatureDescriptor_Data_Single_{
+				Single: &SignatureDescriptor_Data_Single{
+					Mode:      data.SignMode,
+					Signature: data.Signature,
+				},
+			},
+		}
+	case *MultiSignatureData:
+		descDatas := make([]*SignatureDescriptor_Data, len(data.Signatures))
+
+		for j, d := range data.Signatures {
+			descDatas[j] = SignatureDataToSignatureDescriptorData(d)
+		}
+
+		return &SignatureDescriptor_Data{
+			Sum: &SignatureDescriptor_Data_Multi_{
+				Multi: &SignatureDescriptor_Data_Multi{
+					Bitarray:   data.BitArray,
+					Signatures: descDatas,
+				},
+			},
+		}
+	default:
+		panic(fmt.Errorf("unexpected case %+v", data))
+	}
+}
+
+// SignatureDescriptorDataToSignatureData converts a SignatureDescriptor_Data to SignatureData.
+// SignatureDescriptor_Data is considered an encoding type whereas SignatureData is used for
+// business logic.
+func SignatureDescriptorDataToSignatureData(descData *SignatureDescriptor_Data) SignatureData {
+	switch descData := descData.Sum.(type) {
+	case *SignatureDescriptor_Data_Single_:
+		return &SingleSignatureData{
+			SignMode:  descData.Single.Mode,
+			Signature: descData.Single.Signature,
+		}
+	case *SignatureDescriptor_Data_Multi_:
+		multi := descData.Multi
+		datas := make([]SignatureData, len(multi.Signatures))
+
+		for j, d := range multi.Signatures {
+			datas[j] = SignatureDescriptorDataToSignatureData(d)
+		}
+
+		return &MultiSignatureData{
+			BitArray:   multi.Bitarray,
+			Signatures: datas,
+		}
+	default:
+		panic(fmt.Errorf("unexpected case %+v", descData))
+	}
+}