x/auth/ante: Migrate tests to use the new client.TxConfig

client/context.go

@@ -47,7 +47,7 @@ type Context struct {
 	GenerateOnly      bool
 	Offline           bool
 	SkipConfirm       bool
-	TxGenerator       TxGenerator
+	TxConfig          TxConfig
 	AccountRetriever  AccountRetriever
 	NodeURI           string
 	Verifier          tmlite.Verifier
@@ -319,9 +319,9 @@ func (ctx Context) WithSkipConfirmation(skip bool) Context {
 	return ctx
 }
 
-// WithTxGenerator returns the context with an updated TxGenerator
-func (ctx Context) WithTxGenerator(generator TxGenerator) Context {
-	ctx.TxGenerator = generator
+// WithTxConfig returns the context with an updated TxConfig
+func (ctx Context) WithTxConfig(generator TxConfig) Context {
+	ctx.TxConfig = generator
 	return ctx
 }
 

client/testutil/suite.go

@@ -6,7 +6,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec/testdata"
 	"github.com/cosmos/cosmos-sdk/crypto/types/multisig"
 	"github.com/cosmos/cosmos-sdk/x/auth/signing"
-	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/stretchr/testify/suite"
 	"github.com/tendermint/tendermint/crypto"
 
@@ -17,27 +16,27 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// TxGeneratorTestSuite provides a test suite that can be used to test that a TxGenerator implementation is correct
-//nolint:golint  // type name will be used as tx.TxGeneratorTestSuite by other packages, and that stutters; consider calling this GeneratorTestSuite
-type TxGeneratorTestSuite struct {
+// TxConfigTestSuite provides a test suite that can be used to test that a TxConfig implementation is correct
+//nolint:golint  // type name will be used as tx.TxConfigTestSuite by other packages, and that stutters; consider calling this GeneratorTestSuite
+type TxConfigTestSuite struct {
 	suite.Suite
-	TxGenerator client.TxGenerator
+	TxConfig client.TxConfig
 }
 
-// NewTxGeneratorTestSuite returns a new TxGeneratorTestSuite with the provided TxGenerator implementation
-func NewTxGeneratorTestSuite(txGenerator client.TxGenerator) *TxGeneratorTestSuite {
-	return &TxGeneratorTestSuite{TxGenerator: txGenerator}
+// NewTxConfigTestSuite returns a new TxConfigTestSuite with the provided TxConfig implementation
+func NewTxConfigTestSuite(txConfig client.TxConfig) *TxConfigTestSuite {
+	return &TxConfigTestSuite{TxConfig: txConfig}
 }
 
-func (s *TxGeneratorTestSuite) TestTxBuilderGetTx() {
-	txBuilder := s.TxGenerator.NewTxBuilder()
+func (s *TxConfigTestSuite) TestTxBuilderGetTx() {
+	txBuilder := s.TxConfig.NewTxBuilder()
 	tx := txBuilder.GetTx()
 	s.Require().NotNil(tx)
 	s.Require().Equal(len(tx.GetMsgs()), 0)
 }
 
-func (s *TxGeneratorTestSuite) TestTxBuilderSetFeeAmount() {
-	txBuilder := s.TxGenerator.NewTxBuilder()
+func (s *TxConfigTestSuite) TestTxBuilderSetFeeAmount() {
+	txBuilder := s.TxConfig.NewTxBuilder()
 	feeAmount := sdk.Coins{
 		sdk.NewInt64Coin("atom", 20000000),
 	}
@@ -46,30 +45,30 @@ func (s *TxGeneratorTestSuite) TestTxBuilderSetFeeAmount() {
 	s.Require().Equal(feeAmount, feeTx.GetFee())
 }
 
-func (s *TxGeneratorTestSuite) TestTxBuilderSetGasLimit() {
+func (s *TxConfigTestSuite) TestTxBuilderSetGasLimit() {
 	const newGas uint64 = 300000
-	txBuilder := s.TxGenerator.NewTxBuilder()
+	txBuilder := s.TxConfig.NewTxBuilder()
 	txBuilder.SetGasLimit(newGas)
 	feeTx := txBuilder.GetTx()
 	s.Require().Equal(newGas, feeTx.GetGas())
 }
 
-func (s *TxGeneratorTestSuite) TestTxBuilderSetMemo() {
+func (s *TxConfigTestSuite) TestTxBuilderSetMemo() {
 	const newMemo string = "newfoomemo"
-	txBuilder := s.TxGenerator.NewTxBuilder()
+	txBuilder := s.TxConfig.NewTxBuilder()
 	txBuilder.SetMemo(newMemo)
 	txWithMemo := txBuilder.GetTx()
 	s.Require().Equal(txWithMemo.GetMemo(), newMemo)
 }
 
-func (s *TxGeneratorTestSuite) TestTxBuilderSetMsgs() {
-	_, _, addr1 := authtypes.KeyTestPubAddr()
-	_, _, addr2 := authtypes.KeyTestPubAddr()
+func (s *TxConfigTestSuite) TestTxBuilderSetMsgs() {
+	_, _, addr1 := testdata.KeyTestPubAddr()
+	_, _, addr2 := testdata.KeyTestPubAddr()
 	msg1 := testdata.NewTestMsg(addr1)
 	msg2 := testdata.NewTestMsg(addr2)
 	msgs := []sdk.Msg{msg1, msg2}
 
-	txBuilder := s.TxGenerator.NewTxBuilder()
+	txBuilder := s.TxConfig.NewTxBuilder()
 
 	err := txBuilder.SetMsgs(msgs...)
 	s.Require().NoError(err)
@@ -80,12 +79,12 @@ func (s *TxGeneratorTestSuite) TestTxBuilderSetMsgs() {
 	s.Require().Error(tx.ValidateBasic()) // should fail because of no signatures
 }
 
-func (s *TxGeneratorTestSuite) TestTxBuilderSetSignatures() {
-	privKey, pubkey, addr := authtypes.KeyTestPubAddr()
-	privKey2, pubkey2, _ := authtypes.KeyTestPubAddr()
+func (s *TxConfigTestSuite) TestTxBuilderSetSignatures() {
+	privKey, pubkey, addr := testdata.KeyTestPubAddr()
+	privKey2, pubkey2, _ := testdata.KeyTestPubAddr()
 	multisigPk := multisig.NewPubKeyMultisigThreshold(2, []crypto.PubKey{pubkey, pubkey2})
 
-	txBuilder := s.TxGenerator.NewTxBuilder()
+	txBuilder := s.TxConfig.NewTxBuilder()
 
 	// set test msg
 	msg := testdata.NewTestMsg(addr)
@@ -97,7 +96,7 @@ func (s *TxGeneratorTestSuite) TestTxBuilderSetSignatures() {
 	// check that validation fails
 	s.Require().Error(txBuilder.GetTx().ValidateBasic())
 
-	signModeHandler := s.TxGenerator.SignModeHandler()
+	signModeHandler := s.TxConfig.SignModeHandler()
 	s.Require().Contains(signModeHandler.Modes(), signModeHandler.DefaultMode())
 
 	// set SignatureV2 without actual signature bytes
@@ -227,8 +226,8 @@ func sigDataEquals(data1, data2 signingtypes.SignatureData) bool {
 	}
 }
 
-func (s *TxGeneratorTestSuite) TestTxEncodeDecode() {
-	_, pubkey, addr := authtypes.KeyTestPubAddr()
+func (s *TxConfigTestSuite) TestTxEncodeDecode() {
+	_, pubkey, addr := testdata.KeyTestPubAddr()
 	feeAmount := sdk.Coins{sdk.NewInt64Coin("atom", 150)}
 	gasLimit := uint64(50000)
 	memo := "foomemo"
@@ -242,7 +241,7 @@ func (s *TxGeneratorTestSuite) TestTxEncodeDecode() {
 		},
 	}
 
-	txBuilder := s.TxGenerator.NewTxBuilder()
+	txBuilder := s.TxConfig.NewTxBuilder()
 	txBuilder.SetFeeAmount(feeAmount)
 	txBuilder.SetGasLimit(gasLimit)
 	txBuilder.SetMemo(memo)
@@ -253,12 +252,12 @@ func (s *TxGeneratorTestSuite) TestTxEncodeDecode() {
 	tx := txBuilder.GetTx()
 
 	s.T().Log("encode transaction")
-	txBytes, err := s.TxGenerator.TxEncoder()(tx)
+	txBytes, err := s.TxConfig.TxEncoder()(tx)
 	s.Require().NoError(err)
 	s.Require().NotNil(txBytes)
 
 	s.T().Log("decode transaction")
-	tx2, err := s.TxGenerator.TxDecoder()(txBytes)
+	tx2, err := s.TxConfig.TxDecoder()(txBytes)
 	s.Require().NoError(err)
 	tx3, ok := tx2.(signing.SigFeeMemoTx)
 	s.Require().True(ok)
@@ -270,12 +269,12 @@ func (s *TxGeneratorTestSuite) TestTxEncodeDecode() {
 	s.Require().Equal([]crypto.PubKey{pubkey}, tx3.GetPubKeys())
 
 	s.T().Log("JSON encode transaction")
-	jsonTxBytes, err := s.TxGenerator.TxJSONEncoder()(tx)
+	jsonTxBytes, err := s.TxConfig.TxJSONEncoder()(tx)
 	s.Require().NoError(err)
 	s.Require().NotNil(jsonTxBytes)
 
 	s.T().Log("JSON decode transaction")
-	tx2, err = s.TxGenerator.TxJSONDecoder()(jsonTxBytes)
+	tx2, err = s.TxConfig.TxJSONDecoder()(jsonTxBytes)
 	s.Require().NoError(err)
 	tx3, ok = tx2.(signing.SigFeeMemoTx)
 	s.Require().True(ok)

client/tx/factory.go

@@ -17,7 +17,7 @@ import (
 // signing an application-specific transaction.
 type Factory struct {
 	keybase            keyring.Keyring
-	txGenerator        client.TxGenerator
+	txConfig           client.TxConfig
 	accountRetriever   client.AccountRetriever
 	accountNumber      uint64
 	sequence           uint64
@@ -56,7 +56,7 @@ func NewFactoryCLI(clientCtx client.Context, flagSet *pflag.FlagSet) Factory {
 	gasSetting, _ := flags.ParseGasSetting(gasStr)
 
 	f := Factory{
-		txGenerator:        clientCtx.TxGenerator,
+		txConfig:           clientCtx.TxConfig,
 		accountRetriever:   clientCtx.AccountRetriever,
 		keybase:            clientCtx.Keyring,
 		chainID:            clientCtx.ChainID,
@@ -134,9 +134,9 @@ func (f Factory) AccountRetriever() client.AccountRetriever { return f.accountRe
 // using the gas from the simulation results
 func (f Factory) SimulateAndExecute() bool { return f.simulateAndExecute }
 
-// WithTxGenerator returns a copy of the Factory with an updated TxGenerator.
-func (f Factory) WithTxGenerator(g client.TxGenerator) Factory {
-	f.txGenerator = g
+// WithTxConfig returns a copy of the Factory with an updated TxConfig.
+func (f Factory) WithTxConfig(g client.TxConfig) Factory {
+	f.txConfig = g
 	return f
 }
 

client/tx/tx.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/gogo/protobuf/jsonpb"
 	"github.com/spf13/pflag"
+	"github.com/tendermint/tendermint/crypto"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
@@ -33,7 +34,7 @@ func GenerateOrBroadcastTxCLI(clientCtx client.Context, flagSet *pflag.FlagSet,
 //
 // TODO: Remove in favor of GenerateOrBroadcastTxCLI
 func GenerateOrBroadcastTx(clientCtx client.Context, msgs ...sdk.Msg) error {
-	txf := NewFactoryFromDeprecated(clientCtx.Input).WithTxGenerator(clientCtx.TxGenerator).WithAccountRetriever(clientCtx.AccountRetriever)
+	txf := NewFactoryFromDeprecated(clientCtx.Input).WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever)
 	return GenerateOrBroadcastTxWithFactory(clientCtx, txf, msgs...)
 }
 
@@ -124,7 +125,7 @@ func BroadcastTx(clientCtx client.Context, txf Factory, msgs ...sdk.Msg) error {
 		return err
 	}
 
-	txBytes, err := clientCtx.TxGenerator.TxEncoder()(tx.GetTx())
+	txBytes, err := clientCtx.TxConfig.TxEncoder()(tx.GetTx())
 	if err != nil {
 		return err
 	}
@@ -162,7 +163,7 @@ func WriteGeneratedTxResponse(
 		WithMemo(br.Memo).
 		WithChainID(br.ChainID).
 		WithSimulateAndExecute(br.Simulate).
-		WithTxGenerator(ctx.TxGenerator)
+		WithTxConfig(ctx.TxConfig)
 
 	if br.Simulate || gasSetting.Simulate {
 		if gasAdj < 0 {
@@ -225,7 +226,7 @@ func BuildUnsignedTx(txf Factory, msgs ...sdk.Msg) (client.TxBuilder, error) {
 		}
 	}
 
-	tx := txf.txGenerator.NewTxBuilder()
+	tx := txf.txConfig.NewTxBuilder()
 
 	if err := tx.SetMsgs(msgs...); err != nil {
 		return nil, err
@@ -254,7 +255,7 @@ func BuildSimTx(txf Factory, msgs ...sdk.Msg) ([]byte, error) {
 		return nil, err
 	}
 
-	return txf.txGenerator.TxEncoder()(tx.GetTx())
+	return txf.txConfig.TxEncoder()(tx.GetTx())
 }
 
 // CalculateGas simulates the execution of a transaction and returns the
@@ -310,6 +311,46 @@ func PrepareFactory(clientCtx client.Context, txf Factory) (Factory, error) {
 	return txf, nil
 }
 
+// SignWithPrivKey signs a given tx with the given private key, and returns the
+// corresponding SignatureV2 if the signing is successful.
+func SignWithPrivKey(
+	signMode signing.SignMode,
+	signerData authsigning.SignerData,
+	txBuilder client.TxBuilder,
+	priv crypto.PrivKey,
+	txConfig client.TxConfig,
+) (signing.SignatureV2, error) {
+	var sigV2 signing.SignatureV2
+
+	// Generate the bytes to be signed
+	signBytes, err := txConfig.SignModeHandler().GetSignBytes(
+		signMode,
+		signerData,
+		txBuilder.GetTx(),
+	)
+	if err != nil {
+		return sigV2, err
+	}
+
+	// Sign those bytes
+	signature, err := priv.Sign(signBytes)
+	if err != nil {
+		return sigV2, err
+	}
+
+	// Construct the SignatureV2 struct
+	sigData := signing.SingleSignatureData{
+		SignMode:  signMode,
+		Signature: signature,
+	}
+	sigV2 = signing.SignatureV2{
+		PubKey: priv.PubKey(),
+		Data:   &sigData,
+	}
+
+	return sigV2, nil
+}
+
 // Sign signs a given tx with the provided name and passphrase. If the Factory's
 // Keybase is not set, a new one will be created based on the client's backend.
 // The bytes signed over are canconical. The resulting signature will be set on
@@ -318,15 +359,15 @@ func PrepareFactory(clientCtx client.Context, txf Factory) (Factory, error) {
 //
 // Note, It is assumed the Factory has the necessary fields set that are required
 // by the CanonicalSignBytes call.
-func Sign(txf Factory, name string, tx client.TxBuilder) error {
+func Sign(txf Factory, name string, txBuilder client.TxBuilder) error {
 	if txf.keybase == nil {
 		return errors.New("keybase must be set prior to signing a transaction")
 	}
 
 	signMode := txf.signMode
 	if signMode == signing.SignMode_SIGN_MODE_UNSPECIFIED {
 		// use the SignModeHandler's default mode if unspecified
-		signMode = txf.txGenerator.SignModeHandler().DefaultMode()
+		signMode = txf.txConfig.SignModeHandler().DefaultMode()
 	}
 
 	key, err := txf.keybase.Key(name)
@@ -335,43 +376,40 @@ func Sign(txf Factory, name string, tx client.TxBuilder) error {
 	}
 
 	pubKey := key.GetPubKey()
-	sigData := &signing.SingleSignatureData{
-		SignMode:  signMode,
-		Signature: nil,
-	}
-	sig := signing.SignatureV2{
-		PubKey: pubKey,
-		Data:   sigData,
-	}
-	err = tx.SetSignatures(sig)
-	if err != nil {
-		return err
-	}
 
-	signBytes, err := txf.txGenerator.SignModeHandler().GetSignBytes(
+	// Generate the bytes to be signed
+	signerData := authsigning.SignerData{
+		ChainID:         txf.chainID,
+		AccountNumber:   txf.accountNumber,
+		AccountSequence: txf.sequence,
+	}
+	signBytes, err := txf.txConfig.SignModeHandler().GetSignBytes(
 		signMode,
-		authsigning.SignerData{
-			ChainID:         txf.chainID,
-			AccountNumber:   txf.accountNumber,
-			AccountSequence: txf.sequence,
-		}, tx.GetTx(),
+		signerData,
+		txBuilder.GetTx(),
 	)
 	if err != nil {
 		return err
 	}
 
+	// Sign those bytes
 	sigBytes, _, err := txf.keybase.Sign(name, signBytes)
 	if err != nil {
 		return err
 	}
 
-	sigData.Signature = sigBytes
-	sig = signing.SignatureV2{
+	// Construct the SignatureV2 struct
+	sigData := signing.SingleSignatureData{
+		SignMode:  signMode,
+		Signature: sigBytes,
+	}
+	sig := signing.SignatureV2{
 		PubKey: pubKey,
-		Data:   sigData,
+		Data:   &sigData,
 	}
 
-	return tx.SetSignatures(sig)
+	// And here the tx is populated with the signature
+	return txBuilder.SetSignatures(sig)
 }
 
 // GasEstimateResponse defines a response definition for tx gas estimation.