revert: Remove SIGN_MODE_AMINO_AUX (#10322)

<!--
The default pull request template is for types feat, fix, or refactor.
For other templates, add one of the following parameters to the url:
- template=docs.md
- template=other.md
-->

## Description

Revert #10268 

As part of the TX working group, we decided not to introduce a new sign mode for tipper signing. The tipper will use amino-json to sign via ledger (see #10346).

Also, add `signing.SignerData#Address` (will be used in subsequent PR #10346)

<!-- Add a description of the changes that this PR introduces and the files that
are the most critical to review. -->

---

### Author Checklist

*All items are required. Please add a note to the item if the item is not applicable and
please add links to any relevant follow up issues.*

I have...

- [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] added `!` to the type prefix if API or client breaking change
- [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/master/CONTRIBUTING.md#pr-targeting))
- [ ] provided a link to the relevant issue or specification
- [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/master/docs/building-modules)
- [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/master/CONTRIBUTING.md#testing)
- [ ] added a changelog entry to `CHANGELOG.md`
- [ ] included comments for [documenting Go code](https://blog.golang.org/godoc)
- [ ] updated the relevant documentation or specification
- [ ] reviewed "Files changed" and left comments if necessary
- [ ] confirmed all CI checks have passed

### Reviewers Checklist

*All items are required. Please add a note if the item is not applicable and please add
your handle next to the items reviewed if you only reviewed selected items.*

I have...

- [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] confirmed `!` in the type prefix if API or client breaking change
- [ ] confirmed all author checklist items have been addressed 
- [ ] reviewed state machine logic
- [ ] reviewed API design and naming
- [ ] reviewed documentation is accurate
- [ ] reviewed tests and test coverage
- [ ] manually tested (if applicable)

x/auth/client/cli/tx_multisign.go

@@ -127,13 +127,15 @@ func makeMultiSignCmd() func(cmd *cobra.Command, args []string) (err error) {
 				return fmt.Errorf("set the chain id with either the --chain-id flag or config file")
 			}
 
-			signingData := signing.SignerData{
-				ChainID:       txFactory.ChainID(),
-				AccountNumber: txFactory.AccountNumber(),
-				Sequence:      txFactory.Sequence(),
-			}
+			for j, sig := range sigs {
+				signingData := signing.SignerData{
+					Address:       sdk.AccAddress(sig.PubKey.Address()).String(),
+					ChainID:       txFactory.ChainID(),
+					AccountNumber: txFactory.AccountNumber(),
+					Sequence:      txFactory.Sequence(),
+					SignerIndex:   j,
+				}
 
-			for _, sig := range sigs {
 				err = signing.VerifySignature(sig.PubKey, signingData, sig.Data, txCfg.SignModeHandler(), txBuilder.GetTx())
 				if err != nil {
 					addr, _ := sdk.AccAddressFromHex(sig.PubKey.Address().String())
@@ -322,9 +324,11 @@ func makeBatchMultisignCmd() func(cmd *cobra.Command, args []string) error {
 			multisigPub := pubKey.(*kmultisig.LegacyAminoPubKey)
 			multisigSig := multisig.NewMultisig(len(multisigPub.PubKeys))
 			signingData := signing.SignerData{
+				Address:       sdk.AccAddress(pubKey.Address()).String(),
 				ChainID:       txFactory.ChainID(),
 				AccountNumber: txFactory.AccountNumber(),
 				Sequence:      txFactory.Sequence(),
+				SignerIndex:   i,
 			}
 
 			for _, sig := range signatureBatch {

x/auth/client/cli/validate_sigs.go

@@ -106,9 +106,11 @@ func printAndValidateSigs(
 			}
 
 			signingData := authsigning.SignerData{
+				Address:       sigAddr.String(),
 				ChainID:       chainID,
 				AccountNumber: accNum,
 				Sequence:      accSeq,
+				SignerIndex:   i,
 			}
 			err = authsigning.VerifySignature(pubKey, signingData, sig.Data, signModeHandler, sigTx)
 			if err != nil {

x/auth/middleware/feegrant_test.go

@@ -212,9 +212,11 @@ func genTxWithFeeGranter(gen client.TxConfig, msgs []sdk.Msg, feeAmt sdk.Coins,
 	// 2nd round: once all signer infos are set, every signer can sign.
 	for i, p := range priv {
 		signerData := authsign.SignerData{
+			Address:       sdk.AccAddress(p.PubKey().Address()).String(),
 			ChainID:       chainID,
 			AccountNumber: accNums[i],
 			Sequence:      accSeqs[i],
+			SignerIndex:   i,
 		}
 		signBytes, err := gen.SignModeHandler().GetSignBytes(signMode, signerData, tx.GetTx())
 		if err != nil {

x/auth/middleware/sigverify.go

@@ -481,10 +481,13 @@ func (svm sigVerificationTxHandler) sigVerify(ctx context.Context, tx sdk.Tx, is
 		if !genesis {
 			accNum = acc.GetAccountNumber()
 		}
+
 		signerData := authsigning.SignerData{
+			Address:       signerAddrs[i].String(),
 			ChainID:       chainID,
 			AccountNumber: accNum,
 			Sequence:      acc.GetSequence(),
+			SignerIndex:   i,
 		}
 
 		if !simulate {

x/auth/middleware/testutil_test.go

@@ -139,9 +139,11 @@ func (s *MWTestSuite) createTestTx(txBuilder client.TxBuilder, privs []cryptotyp
 	sigsV2 = []signing.SignatureV2{}
 	for i, priv := range privs {
 		signerData := xauthsigning.SignerData{
+			Address:       sdk.AccAddress(priv.PubKey().Address()).String(),
 			ChainID:       chainID,
 			AccountNumber: accNums[i],
 			Sequence:      accSeqs[i],
+			SignerIndex:   i,
 		}
 		sigV2, err := tx.SignWithPrivKey(
 			s.clientCtx.TxConfig.SignModeHandler().DefaultMode(), signerData,

x/auth/migrations/legacytx/amino_signing_test.go

@@ -46,9 +46,11 @@ func TestLegacyAminoJSONHandler_GetSignBytes(t *testing.T) {
 
 	handler := stdTxSignModeHandler{}
 	signingData := signing.SignerData{
+		Address:       addr1.String(),
 		ChainID:       chainId,
 		AccountNumber: accNum,
 		Sequence:      seqNum,
+		SignerIndex:   0,
 	}
 	signBz, err := handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON, signingData, tx)
 	require.NoError(t, err)

x/auth/migrations/legacytx/stdsign_aux.go

@@ -1,47 +0,0 @@
-package legacytx
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/cosmos/cosmos-sdk/codec/legacy"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-type StdSignDocAux struct {
-	AccountNumber uint64            `json:"account_number" yaml:"account_number"`
-	Sequence      uint64            `json:"sequence" yaml:"sequence"`
-	TimeoutHeight uint64            `json:"timeout_height,omitempty" yaml:"timeout_height"`
-	ChainID       string            `json:"chain_id" yaml:"chain_id"`
-	Memo          string            `json:"memo" yaml:"memo"`
-	Msgs          []json.RawMessage `json:"msgs" yaml:"msgs"`
-	Tip           sdk.Coins         `json:"tip" yaml:"tip"`
-}
-
-// StdSignBytes returns the bytes to sign for a transaction.
-func StdSignAuxBytes(chainID string, accnum, sequence, timeout uint64, tip sdk.Coins, msgs []sdk.Msg, memo string) []byte {
-	msgsBytes := make([]json.RawMessage, 0, len(msgs))
-	for _, msg := range msgs {
-		legacyMsg, ok := msg.(LegacyMsg)
-		if !ok {
-			panic(fmt.Errorf("expected %T when using AMINO_AUX", (*LegacyMsg)(nil)))
-		}
-
-		msgsBytes = append(msgsBytes, json.RawMessage(legacyMsg.GetSignBytes()))
-	}
-
-	bz, err := legacy.Cdc.MarshalJSON(StdSignDocAux{
-		AccountNumber: accnum,
-		ChainID:       chainID,
-		Memo:          memo,
-		Msgs:          msgsBytes,
-		Sequence:      sequence,
-		TimeoutHeight: timeout,
-		Tip:           tip,
-	})
-	if err != nil {
-		panic(err)
-	}
-
-	return sdk.MustSortJSON(bz)
-}

x/auth/signing/handler_map_test.go

@@ -60,9 +60,11 @@ func TestHandlerMap_GetSignBytes(t *testing.T) {
 	aminoJSONHandler := legacytx.NewStdTxSignModeHandler()
 
 	signingData := signing.SignerData{
+		Address:       addr1.String(),
 		ChainID:       chainId,
 		AccountNumber: accNum,
 		Sequence:      seqNum,
+		SignerIndex:   0,
 	}
 	signBz, err := handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON, signingData, tx)
 	require.NoError(t, err)

x/auth/signing/sign_mode_handler.go

@@ -23,6 +23,9 @@ type SignModeHandler interface {
 // SignerData is the specific information needed to sign a transaction that generally
 // isn't included in the transaction body itself
 type SignerData struct {
+	// The address of the signer.
+	Address string
+
 	// ChainID is the chain that this transaction is targeted
 	ChainID string
 
@@ -35,6 +38,6 @@ type SignerData struct {
 	// info.
 	Sequence uint64
 
-	// SignerIndex index of signer in the signer_infos array
+	// SignerIndex index of signer in the signer_infos array.
 	SignerIndex int
 }

x/auth/signing/verify_test.go

@@ -49,9 +49,11 @@ func TestVerifySignature(t *testing.T) {
 	msgs := []sdk.Msg{testdata.NewTestMsg(addr)}
 	fee := legacytx.NewStdFee(50000, sdk.Coins{sdk.NewInt64Coin("atom", 150)})
 	signerData := signing.SignerData{
+		Address:       addr.String(),
 		ChainID:       chainId,
 		AccountNumber: acc.GetAccountNumber(),
 		Sequence:      acc.GetSequence(),
+		SignerIndex:   0,
 	}
 	signBytes := legacytx.StdSignBytes(signerData.ChainID, signerData.AccountNumber, signerData.Sequence, 10, fee, msgs, memo)
 	signature, err := priv.Sign(signBytes)

x/auth/testutil/suite.go

@@ -127,9 +127,11 @@ func (s *TxConfigTestSuite) TestTxBuilderSetSignatures() {
 
 	// sign transaction
 	signerData := signing.SignerData{
+		Address:       addr.String(),
 		ChainID:       "test",
 		AccountNumber: 1,
 		Sequence:      seq1,
+		SignerIndex:   0,
 	}
 	signBytes, err := signModeHandler.GetSignBytes(signModeHandler.DefaultMode(), signerData, sigTx)
 	s.Require().NoError(err)
@@ -137,9 +139,11 @@ func (s *TxConfigTestSuite) TestTxBuilderSetSignatures() {
 	s.Require().NoError(err)
 
 	signerData = signing.SignerData{
+		Address:       msigAddr.String(),
 		ChainID:       "test",
 		AccountNumber: 3,
 		Sequence:      mseq,
+		SignerIndex:   0,
 	}
 	mSignBytes, err := signModeHandler.GetSignBytes(signModeHandler.DefaultMode(), signerData, sigTx)
 	s.Require().NoError(err)

x/auth/tx/amino_aux.go

@@ -1,57 +0,0 @@
-package tx
-
-import (
-	"fmt"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-	signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
-
-	"github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx"
-	"github.com/cosmos/cosmos-sdk/x/auth/signing"
-)
-
-var _ signing.SignModeHandler = signModeAminoAuxHandler{}
-
-// signModeAminoAuxHandler defines the SIGN_MODE_AMINO_AUX SignModeHandler
-type signModeAminoAuxHandler struct{}
-
-// DefaultMode implements SignModeHandler.DefaultMode
-func (signModeAminoAuxHandler) DefaultMode() signingtypes.SignMode {
-	return signingtypes.SignMode_SIGN_MODE_AMINO_AUX
-}
-
-// Modes implements SignModeHandler.Modes
-func (signModeAminoAuxHandler) Modes() []signingtypes.SignMode {
-	return []signingtypes.SignMode{signingtypes.SignMode_SIGN_MODE_AMINO_AUX}
-}
-
-// GetSignBytes implements SignModeHandler.GetSignBytes
-func (signModeAminoAuxHandler) GetSignBytes(
-	mode signingtypes.SignMode, data signing.SignerData, tx sdk.Tx,
-) ([]byte, error) {
-
-	if mode != signingtypes.SignMode_SIGN_MODE_AMINO_AUX {
-		return nil, fmt.Errorf("expected %s, got %s", signingtypes.SignMode_SIGN_MODE_AMINO_AUX, mode)
-	}
-
-	protoTx, ok := tx.(*wrapper)
-	if !ok {
-		return nil, fmt.Errorf("can only handle a protobuf Tx, got %T", tx)
-	}
-
-	if protoTx.txBodyHasUnknownNonCriticals {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, aminoNonCriticalFieldsError)
-	}
-
-	body := protoTx.tx.Body
-
-	if len(body.ExtensionOptions) != 0 || len(body.NonCriticalExtensionOptions) != 0 {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "SIGN_MODE_AMINO_AUX does not support protobuf extension options.")
-	}
-
-	return legacytx.StdSignAuxBytes(
-		data.ChainID, data.AccountNumber, data.Sequence, protoTx.GetTimeoutHeight(),
-		protoTx.tx.AuthInfo.Tip.Amount, tx.GetMsgs(), protoTx.GetMemo(),
-	), nil
-}

x/auth/tx/amino_aux_test.go

@@ -1,141 +0,0 @@
-package tx
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/testutil/testdata"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	txtypes "github.com/cosmos/cosmos-sdk/types/tx"
-	signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
-	"github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx"
-	"github.com/cosmos/cosmos-sdk/x/auth/signing"
-)
-
-func TestAminoAuxHandler(t *testing.T) {
-	privKey, pubkey, addr := testdata.KeyTestPubAddr()
-	interfaceRegistry := codectypes.NewInterfaceRegistry()
-	interfaceRegistry.RegisterImplementations((*sdk.Msg)(nil), &testdata.TestMsg{})
-	marshaler := codec.NewProtoCodec(interfaceRegistry)
-
-	txConfig := NewTxConfig(marshaler, []signingtypes.SignMode{signingtypes.SignMode_SIGN_MODE_AMINO_AUX})
-	txBuilder := txConfig.NewTxBuilder()
-
-	accountNumber := uint64(1)
-	chainId := "test-chain"
-	memo := "sometestmemo"
-	msgs := []sdk.Msg{testdata.NewTestMsg(addr)}
-	accSeq := uint64(2) // Arbitrary account sequence
-	timeout := uint64(10)
-	fee := txtypes.Fee{Amount: sdk.NewCoins(sdk.NewInt64Coin("atom", 150)), GasLimit: 20000}
-	tip := sdk.NewCoins(sdk.NewCoin("regen", sdk.NewInt(1000)))
-
-	err := txBuilder.SetMsgs(msgs...)
-	require.NoError(t, err)
-	txBuilder.SetMemo(memo)
-	txBuilder.SetFeeAmount(fee.Amount)
-	txBuilder.SetGasLimit(fee.GasLimit)
-	txBuilder.SetTimeoutHeight(timeout)
-	txBuilder.SetTip(&txtypes.Tip{
-		Amount: tip,
-		Tipper: addr.String(), // Not needed when signing using AMINO_AUX, but putting here for clarity.
-	})
-
-	sigData := &signingtypes.SingleSignatureData{
-		SignMode: signingtypes.SignMode_SIGN_MODE_AMINO_AUX,
-	}
-
-	sig := signingtypes.SignatureV2{
-		PubKey:   pubkey,
-		Data:     sigData,
-		Sequence: accSeq,
-	}
-	err = txBuilder.SetSignatures(sig)
-	require.NoError(t, err)
-
-	signingData := signing.SignerData{
-		ChainID:       chainId,
-		AccountNumber: accountNumber,
-		Sequence:      accSeq,
-		SignerIndex:   0,
-	}
-
-	handler := signModeAminoAuxHandler{}
-	signBytes, err := handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_AMINO_AUX, signingData, txBuilder.GetTx())
-	require.NoError(t, err)
-	require.NotNil(t, signBytes)
-
-	expectedSignBytes := legacytx.StdSignAuxBytes(chainId, accountNumber, accSeq, timeout, tip, msgs, memo)
-	require.NoError(t, err)
-	require.Equal(t, expectedSignBytes, signBytes)
-
-	t.Log("verify that setting signature doesn't change sign bytes")
-	sigData.Signature, err = privKey.Sign(signBytes)
-	require.NoError(t, err)
-	err = txBuilder.SetSignatures(sig)
-	require.NoError(t, err)
-	signBytes, err = handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_AMINO_AUX, signingData, txBuilder.GetTx())
-	require.NoError(t, err)
-	require.Equal(t, expectedSignBytes, signBytes)
-
-	// expect error with wrong sign mode
-	_, err = handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_DIRECT, signingData, txBuilder.GetTx())
-	require.Error(t, err)
-
-	// expect error with extension options
-	bldr := newBuilder()
-	buildTx(t, bldr)
-	any, err := codectypes.NewAnyWithValue(testdata.NewTestMsg())
-	require.NoError(t, err)
-	bldr.tx.Body.ExtensionOptions = []*codectypes.Any{any}
-	tx := bldr.GetTx()
-	_, err = handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_AMINO_AUX, signingData, tx)
-	require.Error(t, err)
-
-	// expect error with non-critical extension options
-	bldr = newBuilder()
-	buildTx(t, bldr)
-	bldr.tx.Body.NonCriticalExtensionOptions = []*codectypes.Any{any}
-	tx = bldr.GetTx()
-	_, err = handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_AMINO_AUX, signingData, tx)
-	require.Error(t, err)
-}
-
-func TestAminoAuxHandler_DefaultMode(t *testing.T) {
-	handler := signModeAminoAuxHandler{}
-	require.Equal(t, signingtypes.SignMode_SIGN_MODE_AMINO_AUX, handler.DefaultMode())
-}
-
-func TestAminoAuxModeHandler_nonDIRECT_MODE(t *testing.T) {
-	invalidModes := []signingtypes.SignMode{
-		signingtypes.SignMode_SIGN_MODE_DIRECT,
-		signingtypes.SignMode_SIGN_MODE_TEXTUAL,
-		signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON,
-		signingtypes.SignMode_SIGN_MODE_UNSPECIFIED,
-		signingtypes.SignMode_SIGN_MODE_DIRECT_AUX,
-	}
-	for _, invalidMode := range invalidModes {
-		t.Run(invalidMode.String(), func(t *testing.T) {
-			var dh signModeAminoAuxHandler
-			var signingData signing.SignerData
-			_, err := dh.GetSignBytes(invalidMode, signingData, nil)
-			require.Error(t, err)
-			wantErr := fmt.Errorf("expected %s, got %s", signingtypes.SignMode_SIGN_MODE_AMINO_AUX, invalidMode)
-			require.Equal(t, err, wantErr)
-		})
-	}
-}
-
-func TestAminoAuxModeHandler_nonProtoTx(t *testing.T) {
-	var ah signModeAminoAuxHandler
-	var signingData signing.SignerData
-	tx := new(nonProtoTx)
-	_, err := ah.GetSignBytes(signingtypes.SignMode_SIGN_MODE_AMINO_AUX, signingData, tx)
-	require.Error(t, err)
-	wantErr := fmt.Errorf("can only handle a protobuf Tx, got %T", tx)
-	require.Equal(t, err, wantErr)
-}

x/auth/tx/direct_aux.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	types "github.com/cosmos/cosmos-sdk/types/tx"
 	signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
-
 	"github.com/cosmos/cosmos-sdk/x/auth/signing"
 )
 
@@ -39,6 +39,11 @@ func (signModeDirectAuxHandler) GetSignBytes(
 		return nil, fmt.Errorf("can only handle a protobuf Tx, got %T", tx)
 	}
 
+	signerInfo := protoTx.tx.AuthInfo.SignerInfos[data.SignerIndex]
+	if signerInfo == nil || signerInfo.PublicKey == nil {
+		return nil, sdkerrors.ErrInvalidRequest.Wrapf("got empty pubkey for signer #%d in %s handler", data.SignerIndex, signingtypes.SignMode_SIGN_MODE_DIRECT_AUX)
+	}
+
 	signDocDirectAux := types.SignDocDirectAux{
 		BodyBytes:     protoTx.getBodyBytes(),
 		ChainId:       data.ChainID,

x/auth/tx/direct_aux_test.go

@@ -53,8 +53,10 @@ func TestDirectAuxHandler(t *testing.T) {
 	require.NoError(t, err)
 
 	signingData := signing.SignerData{
+		Address:       addr.String(),
 		ChainID:       "test-chain",
 		AccountNumber: 1,
+		SignerIndex:   0,
 	}
 
 	modeHandler := signModeDirectAuxHandler{}

x/auth/tx/direct_test.go

@@ -69,8 +69,10 @@ func TestDirectModeHandler(t *testing.T) {
 	require.Len(t, modeHandler.Modes(), 1)
 
 	signingData := signing.SignerData{
+		Address:       addr.String(),
 		ChainID:       "test-chain",
 		AccountNumber: 1,
+		SignerIndex:   0,
 	}
 
 	signBytes, err := modeHandler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_DIRECT, signingData, txBuilder.GetTx())

x/auth/tx/legacy_amino_json.go

@@ -43,7 +43,7 @@ func (s signModeLegacyAminoJSONHandler) GetSignBytes(mode signingtypes.SignMode,
 	body := protoTx.tx.Body
 
 	if len(body.ExtensionOptions) != 0 || len(body.NonCriticalExtensionOptions) != 0 {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "SIGN_MODE_LEGACY_AMINO_JSON does not support protobuf extension options.")
+		return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "%s does not support protobuf extension options", signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON)
 	}
 
 	return legacytx.StdSignBytes(

x/auth/tx/legacy_amino_json_test.go

@@ -45,9 +45,11 @@ func TestLegacyAminoJSONHandler_GetSignBytes(t *testing.T) {
 
 	handler := signModeLegacyAminoJSONHandler{}
 	signingData := signing.SignerData{
+		Address:       addr1.String(),
 		ChainID:       chainId,
 		AccountNumber: accNum,
 		Sequence:      seqNum,
+		SignerIndex:   0,
 	}
 	signBz, err := handler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON, signingData, tx)
 	require.NoError(t, err)

x/auth/tx/mode_handler.go

@@ -11,10 +11,11 @@ import (
 var DefaultSignModes = []signingtypes.SignMode{
 	signingtypes.SignMode_SIGN_MODE_DIRECT,
 	signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON,
+	signingtypes.SignMode_SIGN_MODE_DIRECT_AUX,
 }
 
 // makeSignModeHandler returns the default protobuf SignModeHandler supporting
-// SIGN_MODE_DIRECT and SIGN_MODE_LEGACY_AMINO_JSON.
+// SIGN_MODE_DIRECT, SIGN_MODE_DIRECT_AUX and SIGN_MODE_LEGACY_AMINO_JSON.
 func makeSignModeHandler(modes []signingtypes.SignMode) signing.SignModeHandler {
 	if len(modes) < 1 {
 		panic(fmt.Errorf("no sign modes enabled"))
@@ -30,8 +31,6 @@ func makeSignModeHandler(modes []signingtypes.SignMode) signing.SignModeHandler
 			handlers[i] = signModeLegacyAminoJSONHandler{}
 		case signingtypes.SignMode_SIGN_MODE_DIRECT_AUX:
 			handlers[i] = signModeDirectAuxHandler{}
-		case signingtypes.SignMode_SIGN_MODE_AMINO_AUX:
-			handlers[i] = signModeAminoAuxHandler{}
 		default:
 			panic(fmt.Errorf("unsupported sign mode %+v", mode))
 		}

x/authz/query.pb.go

@@ -156,7 +156,7 @@ func (m *QueryGrantsResponse) GetPagination() *query.PageResponse {
 	return nil
 }
 
-// QueryGranterGrantsRequest is the request type for the Query/Grants RPC method.
+// QueryGranterGrantsRequest is the request type for the Query/GranterGrants RPC method.
 type QueryGranterGrantsRequest struct {
 	Granter string `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
 	// pagination defines an pagination for the request.