Revert: Generalize auth/types.StdSignature (#4507)

client/keys/import.go

@@ -3,9 +3,8 @@ package keys
 import (
 	"io/ioutil"
 
-	"github.com/spf13/cobra"
-
 	"github.com/cosmos/cosmos-sdk/client/input"
+	"github.com/spf13/cobra"
 )
 
 func importKeyCommand() *cobra.Command {

client/keys/list.go

@@ -1,9 +1,8 @@
 package keys
 
 import (
-	"github.com/spf13/cobra"
-
 	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/spf13/cobra"
 )
 
 func listKeysCmd() *cobra.Command {

client/keys/mnemonic_test.go

@@ -5,10 +5,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/cosmos/cosmos-sdk/client/input"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/cosmos/cosmos-sdk/client/input"
 )
 
 func Test_RunMnemonicCmdNormal(t *testing.T) {

client/keys/update.go

@@ -3,9 +3,8 @@ package keys
 import (
 	"fmt"
 
-	"github.com/spf13/cobra"
-
 	"github.com/cosmos/cosmos-sdk/client/input"
+	"github.com/spf13/cobra"
 )
 
 func updateKeyCommand() *cobra.Command {

client/utils/utils_test.go

@@ -100,7 +100,7 @@ func TestReadStdTxFromFile(t *testing.T) {
 
 	// Build a test transaction
 	fee := authtypes.NewStdFee(50000, sdk.Coins{sdk.NewInt64Coin("atom", 150)})
-	stdTx := authtypes.NewStdTx([]sdk.Msg{}, fee, nil, "foomemo")
+	stdTx := authtypes.NewStdTx([]sdk.Msg{}, fee, []authtypes.StdSignature{}, "foomemo")
 
 	// Write it to the file
 	encodedTx, _ := cdc.MarshalJSON(stdTx)
@@ -143,8 +143,8 @@ func TestValidateCmd(t *testing.T) {
 	}{
 		{"misspelled command", []string{"comission"}, true},
 		{"no command provided", []string{}, false},
-		{"help flag", []string{"commission", "--help"}, false},
-		{"shorthand help flag", []string{"commission", "-h"}, false},
+		{"help flag", []string{"comission", "--help"}, false},
+		{"shorthand help flag", []string{"comission", "-h"}, false},
 	}
 
 	for _, tt := range tests {
@@ -158,7 +158,7 @@ func TestValidateCmd(t *testing.T) {
 
 func compareEncoders(t *testing.T, expected sdk.TxEncoder, actual sdk.TxEncoder) {
 	msgs := []sdk.Msg{sdk.NewTestMsg(addr)}
-	tx := authtypes.NewStdTx(msgs, authtypes.StdFee{}, []sdk.Signature{}, "")
+	tx := authtypes.NewStdTx(msgs, authtypes.StdFee{}, []authtypes.StdSignature{}, "")
 
 	defaultEncoderBytes, err := expected(tx)
 	require.NoError(t, err)

contrib/runsim/main.go

@@ -26,7 +26,7 @@ var (
 		989182, 89182391, 11, 22, 44, 77, 99, 2020,
 		3232, 123123, 124124, 582582, 18931893,
 		29892989, 30123012, 47284728, 7601778, 8090485,
-		977367484, 491163361, 424254581, 673398983,
+		977367484, 491163361, 424254581, 673398983,		
 	}
 
 	// goroutine-safe process map

docs/spec/auth/03_types.md

@@ -20,9 +20,9 @@ type StdFee struct {
 
 ## StdSignature
 
-`StdSignature` implements the `sdk.Signature` interface and consists of a combination of an
-optional public key and a cryptographic signature as a byte slice. The SDK is agnostic to
-particular key or signature formats and supports any supported by the `PubKey` interface.
+A `StdSignature` is the combination of an optional public key and a cryptographic signature
+as a byte array. The SDK is agnostic to particular key or signature formats and supports any
+supported by the `PubKey` interface.
 
 ```golang
 type StdSignature struct {

simapp/test_util.go

@@ -5,11 +5,10 @@ import (
 
 	"github.com/tendermint/tendermint/libs/log"
 
-	dbm "github.com/tendermint/tendermint/libs/db"
-
 	bam "github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/staking"
+	dbm "github.com/tendermint/tendermint/libs/db"
 )
 
 // NewSimAppUNSAFE is used for debugging purposes only.

types/codec.go

@@ -6,5 +6,4 @@ import "github.com/cosmos/cosmos-sdk/codec"
 func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterInterface((*Msg)(nil), nil)
 	cdc.RegisterInterface((*Tx)(nil), nil)
-	cdc.RegisterInterface((*Signature)(nil), nil)
 }

types/coin_test.go

@@ -4,10 +4,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/cosmos/cosmos-sdk/codec"
 )
 
 var (

types/tx_msg.go

@@ -2,8 +2,6 @@ package types
 
 import (
 	"encoding/json"
-
-	"github.com/tendermint/tendermint/crypto"
 )
 
 // Transactions messages must fulfill the Msg
@@ -44,12 +42,6 @@ type Tx interface {
 
 //__________________________________________________________
 
-// Signature defines the properties of the signature payload.
-type Signature interface {
-	GetPubKey() crypto.PubKey
-	GetSignature() []byte
-}
-
 // TxDecoder unmarshals transaction bytes
 type TxDecoder func(txBytes []byte) (Tx, Error)
 

x/auth/alias.go

@@ -46,7 +46,6 @@ var (
 	NewStdTx                       = types.NewStdTx
 	CountSubKeys                   = types.CountSubKeys
 	NewStdFee                      = types.NewStdFee
-	NewStdSignature                = types.NewStdSignature
 	StdSignBytes                   = types.StdSignBytes
 	DefaultTxDecoder               = types.DefaultTxDecoder
 	DefaultTxEncoder               = types.DefaultTxEncoder

x/auth/ante.go

@@ -136,8 +136,7 @@ func NewAnteHandler(ak AccountKeeper, fck FeeCollectionKeeper, sigGasConsumer Si
 
 			// check signature, return account with incremented nonce
 			signBytes := GetSignBytes(newCtx.ChainID(), stdTx, signerAccs[i], isGenesis)
-			signerAccs[i], res = processSig(newCtx, signerAccs[i], stdSigs[i], signBytes,
-				simulate, params, sigGasConsumer)
+			signerAccs[i], res = processSig(newCtx, signerAccs[i], stdSigs[i], signBytes, simulate, params, sigGasConsumer)
 			if !res.IsOK() {
 				return newCtx, res, true
 			}
@@ -166,7 +165,7 @@ func ValidateSigCount(stdTx StdTx, params Params) sdk.Result {
 
 	sigCount := 0
 	for i := 0; i < len(stdSigs); i++ {
-		sigCount += CountSubKeys(stdSigs[i].GetPubKey())
+		sigCount += CountSubKeys(stdSigs[i].PubKey)
 		if uint64(sigCount) > params.TxSigLimit {
 			return sdk.ErrTooManySignatures(
 				fmt.Sprintf("signatures: %d, limit: %d", sigCount, params.TxSigLimit),
@@ -195,7 +194,7 @@ func ValidateMemo(stdTx StdTx, params Params) sdk.Result {
 // verify the signature and increment the sequence. If the account doesn't have
 // a pubkey, set it.
 func processSig(
-	ctx sdk.Context, acc Account, sig sdk.Signature, signBytes []byte, simulate bool, params Params,
+	ctx sdk.Context, acc Account, sig StdSignature, signBytes []byte, simulate bool, params Params,
 	sigGasConsumer SignatureVerificationGasConsumer,
 ) (updatedAcc Account, res sdk.Result) {
 
@@ -217,11 +216,11 @@ func processSig(
 		consumeSimSigGas(ctx.GasMeter(), pubKey, sig, params)
 	}
 
-	if res := sigGasConsumer(ctx.GasMeter(), sig.GetSignature(), pubKey, params); !res.IsOK() {
+	if res := sigGasConsumer(ctx.GasMeter(), sig.Signature, pubKey, params); !res.IsOK() {
 		return nil, res
 	}
 
-	if !simulate && !pubKey.VerifyBytes(signBytes, sig.GetSignature()) {
+	if !simulate && !pubKey.VerifyBytes(signBytes, sig.Signature) {
 		return nil, sdk.ErrUnauthorized("signature verification failed; verify correct account sequence and chain-id").Result()
 	}
 
@@ -232,9 +231,9 @@ func processSig(
 	return acc, res
 }
 
-func consumeSimSigGas(gasmeter sdk.GasMeter, pubkey crypto.PubKey, sig sdk.Signature, params Params) {
-	simSig := NewStdSignature(pubkey, nil)
-	if len(sig.GetSignature()) == 0 {
+func consumeSimSigGas(gasmeter sdk.GasMeter, pubkey crypto.PubKey, sig StdSignature, params Params) {
+	simSig := StdSignature{PubKey: pubkey}
+	if len(sig.Signature) == 0 {
 		simSig.Signature = simSecp256k1Sig[:]
 	}
 
@@ -253,7 +252,7 @@ func consumeSimSigGas(gasmeter sdk.GasMeter, pubkey crypto.PubKey, sig sdk.Signa
 // ProcessPubKey verifies that the given account address matches that of the
 // StdSignature. In addition, it will set the public key of the account if it
 // has not been set.
-func ProcessPubKey(acc Account, sig sdk.Signature, simulate bool) (crypto.PubKey, sdk.Result) {
+func ProcessPubKey(acc Account, sig StdSignature, simulate bool) (crypto.PubKey, sdk.Result) {
 	// If pubkey is not known for account, set it from the StdSignature.
 	pubKey := acc.GetPubKey()
 	if simulate {
@@ -269,7 +268,7 @@ func ProcessPubKey(acc Account, sig sdk.Signature, simulate bool) (crypto.PubKey
 	}
 
 	if pubKey == nil {
-		pubKey = sig.GetPubKey()
+		pubKey = sig.PubKey
 		if pubKey == nil {
 			return nil, sdk.ErrInvalidPubKey("PubKey not found").Result()
 		}

x/auth/ante_test.go

@@ -515,8 +515,7 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
 	msgs = []sdk.Msg{msg}
 	tx = NewTestTx(ctx, msgs, privs, []uint64{1}, seqs, fee)
 	sigs := tx.(types.StdTx).GetSignatures()
-	sig := sigs[0].(StdSignature)
-	sig.PubKey = nil
+	sigs[0].PubKey = nil
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeInvalidPubKey)
 
 	acc2 = input.ak.GetAccount(ctx, addr2)
@@ -552,11 +551,11 @@ func TestProcessPubKey(t *testing.T) {
 		args    args
 		wantErr bool
 	}{
-		{"no sigs, simulate off", args{acc1, NewStdSignature(nil, nil), false}, true},
-		{"no sigs, simulate on", args{acc1, NewStdSignature(nil, nil), true}, false},
-		{"no sigs, account with pub, simulate on", args{acc2, NewStdSignature(nil, nil), true}, false},
-		{"pubkey doesn't match addr, simulate off", args{acc1, NewStdSignature(priv2.PubKey(), nil), false}, true},
-		{"pubkey doesn't match addr, simulate on", args{acc1, NewStdSignature(priv2.PubKey(), nil), true}, false},
+		{"no sigs, simulate off", args{acc1, StdSignature{}, false}, true},
+		{"no sigs, simulate on", args{acc1, StdSignature{}, true}, false},
+		{"no sigs, account with pub, simulate on", args{acc2, StdSignature{}, true}, false},
+		{"pubkey doesn't match addr, simulate off", args{acc1, StdSignature{PubKey: priv2.PubKey()}, false}, true},
+		{"pubkey doesn't match addr, simulate on", args{acc1, StdSignature{PubKey: priv2.PubKey()}, true}, false},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

x/auth/client/cli/tx_multisign.go

@@ -18,7 +18,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/utils"
 	"github.com/cosmos/cosmos-sdk/codec"
 	crkeys "github.com/cosmos/cosmos-sdk/crypto/keys"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
 )
@@ -120,8 +119,7 @@ func makeMultiSignCmd(cdc *codec.Codec) func(cmd *cobra.Command, args []string)
 		}
 
 		newStdSig := types.StdSignature{Signature: cdc.MustMarshalBinaryBare(multisigSig), PubKey: multisigPub}
-		newTx := types.NewStdTx(stdTx.GetMsgs(), stdTx.Fee, []sdk.Signature{newStdSig},
-			stdTx.GetMemo())
+		newTx := types.NewStdTx(stdTx.GetMsgs(), stdTx.Fee, []types.StdSignature{newStdSig}, stdTx.GetMemo())
 
 		sigOnly := viper.GetBool(flagSigOnly)
 		var json []byte

x/auth/client/cli/tx_sign.go

@@ -206,7 +206,7 @@ func printAndValidateSigs(
 	}
 
 	for i, sig := range sigs {
-		sigAddr := sdk.AccAddress(sig.GetPubKey().Address())
+		sigAddr := sdk.AccAddress(sig.Address())
 		sigSanity := "OK"
 
 		var (
@@ -233,16 +233,16 @@ func printAndValidateSigs(
 				stdTx.Fee, stdTx.GetMsgs(), stdTx.GetMemo(),
 			)
 
-			if ok := sig.GetPubKey().VerifyBytes(sigBytes, sig.GetSignature()); !ok {
+			if ok := sig.VerifyBytes(sigBytes, sig.Signature); !ok {
 				sigSanity = "ERROR: signature invalid"
 				success = false
 			}
 		}
 
-		multiPK, ok := sig.GetPubKey().(multisig.PubKeyMultisigThreshold)
+		multiPK, ok := sig.PubKey.(multisig.PubKeyMultisigThreshold)
 		if ok {
 			var multiSig multisig.Multisignature
-			cliCtx.Codec.MustUnmarshalBinaryBare(sig.GetSignature(), &multiSig)
+			cliCtx.Codec.MustUnmarshalBinaryBare(sig.Signature, &multiSig)
 
 			var b strings.Builder
 			b.WriteString("\n  MultiSig Signatures:\n")

x/auth/genaccounts/genesis_state_test.go

@@ -3,11 +3,10 @@ package genaccounts
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
-	"github.com/tendermint/tendermint/crypto/ed25519"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/crypto/ed25519"
 )
 
 func TestSanitize(t *testing.T) {

x/auth/types/codec.go

@@ -13,7 +13,6 @@ func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(&ContinuousVestingAccount{}, "auth/ContinuousVestingAccount", nil)
 	cdc.RegisterConcrete(&DelayedVestingAccount{}, "auth/DelayedVestingAccount", nil)
 	cdc.RegisterConcrete(StdTx{}, "auth/StdTx", nil)
-	cdc.RegisterConcrete(StdSignature{}, "auth/StdSignature", nil)
 }
 
 // RegisterBaseAccount most users shouldn't use this, but this comes in handy for tests.

x/auth/types/stdtx.go

@@ -12,22 +12,21 @@ import (
 )
 
 var (
-	_ sdk.Tx        = (*StdTx)(nil)
-	_ sdk.Signature = (*StdSignature)(nil)
+	_ sdk.Tx = (*StdTx)(nil)
 
 	maxGasWanted = uint64((1 << 63) - 1)
 )
 
 // StdTx is a standard way to wrap a Msg with Fee and Signatures.
 // NOTE: the first signature is the fee payer (Signatures must not be nil).
 type StdTx struct {
-	Msgs       []sdk.Msg       `json:"msg"`
-	Fee        StdFee          `json:"fee"`
-	Signatures []sdk.Signature `json:"signatures"`
-	Memo       string          `json:"memo"`
+	Msgs       []sdk.Msg      `json:"msg"`
+	Fee        StdFee         `json:"fee"`
+	Signatures []StdSignature `json:"signatures"`
+	Memo       string         `json:"memo"`
 }
 
-func NewStdTx(msgs []sdk.Msg, fee StdFee, sigs []sdk.Signature, memo string) StdTx {
+func NewStdTx(msgs []sdk.Msg, fee StdFee, sigs []StdSignature, memo string) StdTx {
 	return StdTx{
 		Msgs:       msgs,
 		Fee:        fee,
@@ -105,7 +104,7 @@ func (tx StdTx) GetMemo() string { return tx.Memo }
 // CONTRACT: If the signature is missing (ie the Msg is
 // invalid), then the corresponding signature is
 // .Empty().
-func (tx StdTx) GetSignatures() []sdk.Signature { return tx.Signatures }
+func (tx StdTx) GetSignatures() []StdSignature { return tx.Signatures }
 
 //__________________________________________________________
 
@@ -192,17 +191,6 @@ type StdSignature struct {
 	Signature     []byte           `json:"signature"`
 }
 
-// NewStdSignature constructs a new StdSignature instance.
-func NewStdSignature(pubKey crypto.PubKey, signature []byte) StdSignature {
-	return StdSignature{PubKey: pubKey, Signature: signature}
-}
-
-// GetPubKey returns the embedded crypto.PubKey type.
-func (sig StdSignature) GetPubKey() crypto.PubKey { return sig.PubKey }
-
-// GetSignature returns the embedded byte signature.
-func (sig StdSignature) GetSignature() []byte { return sig.Signature }
-
 // DefaultTxDecoder logic for standard transaction decoding
 func DefaultTxDecoder(cdc *codec.Codec) sdk.TxDecoder {
 	return func(txBytes []byte) (sdk.Tx, sdk.Error) {