feat(x/bank): autocli tx support

tests/e2e/authz/tx.go

@@ -147,14 +147,24 @@ func (s *E2ETestSuite) createAccount(uid string) sdk.AccAddress {
 func (s *E2ETestSuite) msgSendExec(grantee sdk.AccAddress) {
 	val := s.network.Validators[0]
 	// Send some funds to the new account.
-	out, err := clitestutil.MsgSendExec(
-		val.ClientCtx,
-		val.Address,
-		grantee,
-		sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(200))), addresscodec.NewBech32Codec("cosmos"), fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
-		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
-		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))).String()),
+
+	from := val.Address
+	coins := sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(200)))
+	msgSend := &bank.MsgSend{
+		FromAddress: from.String(),
+		ToAddress:   grantee.String(),
+		Amount:      coins,
+	}
+
+	out, err := clitestutil.SubmitTestTx(
+		val,
+		msgSend,
+		from,
+		clitestutil.SubmitTestTxConfig{
+			GenOnly: false,
+		},
 	)
+
 	s.Require().NoError(err)
 	s.Require().Contains(out.String(), `"code":0`)
 	s.Require().NoError(s.network.WaitForNextBlock())
@@ -495,20 +505,24 @@ func (s *E2ETestSuite) TestNewExecGrantAuthorized() {
 	s.Require().NoError(err)
 	s.Require().NoError(s.network.WaitForNextBlock())
 
+	from := val.Address
 	tokens := sdk.NewCoins(
 		sdk.NewCoin(fmt.Sprintf("%stoken", val.Moniker), math.NewInt(12)),
 	)
-	normalGeneratedTx, err := clitestutil.MsgSendExec(
-		val.ClientCtx,
-		val.Address,
-		grantee,
-		tokens,
-		addresscodec.NewBech32Codec("cosmos"),
-		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
-		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
-		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))).String()),
-		fmt.Sprintf("--%s=true", flags.FlagGenerateOnly),
+	msgSend := &bank.MsgSend{
+		FromAddress: from.String(),
+		ToAddress:   grantee.String(),
+		Amount:      tokens,
+	}
+	normalGeneratedTx, err := clitestutil.SubmitTestTx(
+		val,
+		msgSend,
+		from,
+		clitestutil.SubmitTestTxConfig{
+			GenOnly: true,
+		},
 	)
+
 	s.Require().NoError(err)
 	execMsg := testutil.WriteToNewTempFile(s.T(), normalGeneratedTx.String())
 	defer execMsg.Close()
@@ -609,35 +623,40 @@ func (s *E2ETestSuite) TestExecSendAuthzWithAllowList() {
 	s.Require().NoError(err)
 	s.Require().NoError(s.network.WaitForNextBlock())
 
+	from := val.Address
 	tokens := sdk.NewCoins(
 		sdk.NewCoin("stake", math.NewInt(12)),
 	)
+	msgSend := &bank.MsgSend{
+		FromAddress: from.String(),
+		ToAddress:   allowedAddr.String(),
+		Amount:      tokens,
+	}
 
-	validGeneratedTx, err := clitestutil.MsgSendExec(
-		val.ClientCtx,
-		val.Address,
-		allowedAddr,
-		tokens,
-		addresscodec.NewBech32Codec("cosmos"),
-		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
-		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
-		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))).String()),
-		fmt.Sprintf("--%s=true", flags.FlagGenerateOnly),
+	validGeneratedTx, err := clitestutil.SubmitTestTx(
+		val,
+		msgSend,
+		from,
+		clitestutil.SubmitTestTxConfig{
+			GenOnly: true,
+		},
 	)
 	s.Require().NoError(err)
 	execMsg := testutil.WriteToNewTempFile(s.T(), validGeneratedTx.String())
 	defer execMsg.Close()
 
-	invalidGeneratedTx, err := clitestutil.MsgSendExec(
-		val.ClientCtx,
-		val.Address,
-		notAllowedAddr,
-		tokens,
-		addresscodec.NewBech32Codec("cosmos"),
-		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
-		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
-		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))).String()),
-		fmt.Sprintf("--%s=true", flags.FlagGenerateOnly),
+	msgSend1 := &bank.MsgSend{
+		FromAddress: from.String(),
+		ToAddress:   notAllowedAddr.String(),
+		Amount:      tokens,
+	}
+	invalidGeneratedTx, err := clitestutil.SubmitTestTx(
+		val,
+		msgSend1,
+		from,
+		clitestutil.SubmitTestTxConfig{
+			GenOnly: true,
+		},
 	)
 	s.Require().NoError(err)
 	execMsg1 := testutil.WriteToNewTempFile(s.T(), invalidGeneratedTx.String())

testutil/cli/cmd.go

@@ -1,16 +1,25 @@
 package cli
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 
+	"github.com/cosmos/gogoproto/proto"
 	"github.com/spf13/cobra"
 
 	"cosmossdk.io/core/address"
 
+	sdkmath "cosmossdk.io/math"
 	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
 	"github.com/cosmos/cosmos-sdk/testutil"
-	"github.com/cosmos/cosmos-sdk/x/bank/client/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	txtypes "github.com/cosmos/cosmos-sdk/types/tx"
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 )
 
 // ExecTestCLICmd builds the client context, mocks the output and executes the command.
@@ -34,5 +43,215 @@ func MsgSendExec(clientCtx client.Context, from, to, amount fmt.Stringer, ac add
 	args := []string{from.String(), to.String(), amount.String()}
 	args = append(args, extraArgs...)
 
-	return ExecTestCLICmd(clientCtx, cli.NewSendTxCmd(ac), args)
+	coins, err := sdk.ParseCoinsNormalized(amount.String())
+	if err != nil {
+		return nil, err
+	}
+
+	txBuilder := clientCtx.TxConfig.NewTxBuilder()
+	msgSend := banktypes.MsgSend{
+		FromAddress: from.String(),
+		ToAddress:   to.String(),
+		Amount:      coins,
+	}
+
+	fee := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(0)))
+	txBuilder.SetFeeAmount(fee)    // Arbitrary fee
+	txBuilder.SetGasLimit(1000000) // Need at least 100386
+
+	err = txBuilder.SetMsgs(&msgSend)
+	if err != nil {
+		return nil, err
+	}
+
+	txFactory := tx.Factory{}
+	txFactory = txFactory.
+		WithChainID(clientCtx.ChainID).
+		WithKeybase(clientCtx.Keyring).
+		WithTxConfig(clientCtx.TxConfig)
+
+	accBytes, err := clientCtx.AddressCodec.StringToBytes(from.String())
+	if err != nil {
+		return nil, err
+	}
+
+	keyRecord, err := clientCtx.Keyring.KeyByAddress(accBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Sign(context.Background(), txFactory, keyRecord.Name, txBuilder, true)
+	if err != nil {
+		return nil, err
+	}
+
+	txBz, err := clientCtx.TxConfig.TxJSONEncoder()(txBuilder.GetTx())
+	if err != nil {
+		return nil, err
+	}
+
+	req := &txtypes.BroadcastTxRequest{
+		TxBytes: txBz,
+		Mode:    txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
+	}
+
+	serviceClient := txtypes.NewServiceClient(clientCtx)
+	resp, err := serviceClient.BroadcastTx(context.Background(), req)
+
+	fmt.Println("Resp", resp, err, resp.TxResponse.Code)
+
+	// return resp, err
+	return nil, nil
+}
+
+func GenOrBroadcastTestTx(clientCtx client.Context, msg proto.Message, from sdk.AccAddress, generateonly bool) (testutil.BufferWriter, error) {
+	txBuilder := clientCtx.TxConfig.NewTxBuilder()
+
+	fee := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10)))
+	txBuilder.SetFeeAmount(fee)    // Arbitrary fee
+	txBuilder.SetGasLimit(1000000) // Need at least 100386
+
+	err := txBuilder.SetMsgs(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	if generateonly {
+		txBz, err := clientCtx.TxConfig.TxJSONEncoder()(txBuilder.GetTx())
+		if err != nil {
+			return nil, err
+		}
+
+		out := bytes.NewBuffer(txBz)
+		return out, nil
+	}
+
+	txFactory := tx.Factory{}
+	txFactory = txFactory.
+		WithChainID(clientCtx.ChainID).
+		WithKeybase(clientCtx.Keyring).
+		WithTxConfig(clientCtx.TxConfig).
+		WithSignMode(signing.SignMode_SIGN_MODE_DIRECT)
+
+	accBytes, err := clientCtx.AddressCodec.StringToBytes(from.String())
+	if err != nil {
+		return nil, err
+	}
+
+	keyRecord, err := clientCtx.Keyring.KeyByAddress(accBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Sign(context.Background(), txFactory, keyRecord.Name, txBuilder, true)
+	if err != nil {
+		return nil, err
+	}
+
+	txBz, err := clientCtx.TxConfig.TxEncoder()(txBuilder.GetTx())
+	if err != nil {
+		return nil, err
+	}
+
+	req := &txtypes.BroadcastTxRequest{
+		TxBytes: txBz,
+		Mode:    txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
+	}
+
+	serviceClient := txtypes.NewServiceClient(clientCtx)
+	resp, err := serviceClient.BroadcastTx(context.Background(), req)
+	if err != nil {
+		return nil, err
+	}
+
+	respBz, err := clientCtx.Codec.Marshal(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	out := bytes.NewBuffer(respBz)
+	return out, nil
+}
+
+type SubmitTestTxConfig struct {
+	Simulate bool
+	GenOnly  bool
+	Memo     string
+	Gas      uint64
+}
+
+func SubmitTestTx(val *network.Validator, msg proto.Message, from sdk.AccAddress, config SubmitTestTxConfig) (testutil.BufferWriter, error) {
+	clientCtx := val.ClientCtx
+	txBuilder := clientCtx.TxConfig.NewTxBuilder()
+
+	err := txBuilder.SetMsgs(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	fee := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10)))
+	txBuilder.SetFeeAmount(fee) // Arbitrary fee
+
+	if config.Gas != 0 {
+		txBuilder.SetGasLimit(config.Gas)
+	} else {
+		txBuilder.SetGasLimit(flags.DefaultGasLimit) // Need at least 100386
+	}
+
+	if config.Memo != "" {
+		txBuilder.SetMemo(config.Memo)
+	}
+
+	if config.GenOnly {
+		txBz, err := val.ClientCtx.TxConfig.TxJSONEncoder()(txBuilder.GetTx())
+		if err != nil {
+			return nil, err
+		}
+
+		out := bytes.NewBuffer(txBz)
+		return out, nil
+	}
+
+	acc, err := clientCtx.AccountRetriever.GetAccount(clientCtx, from)
+	if err != nil {
+		return nil, err
+	}
+
+	txFactory := tx.Factory{}
+	txFactory = txFactory.
+		WithChainID(clientCtx.ChainID).
+		WithKeybase(clientCtx.Keyring).
+		WithTxConfig(clientCtx.TxConfig).
+		WithSignMode(signing.SignMode_SIGN_MODE_DIRECT).
+		WithAccountNumber(acc.GetAccountNumber()).
+		WithSequence(acc.GetSequence())
+
+	if config.Simulate {
+		txFactory = txFactory.WithSimulateAndExecute(true)
+	}
+
+	accBytes, err := clientCtx.AddressCodec.StringToBytes(from.String())
+	if err != nil {
+		return nil, err
+	}
+
+	keyRecord, err := clientCtx.Keyring.KeyByAddress(accBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	err = tx.Sign(context.Background(), txFactory, keyRecord.Name, txBuilder, true)
+	if err != nil {
+		return nil, err
+	}
+
+	txBz, err := val.ClientCtx.TxConfig.TxEncoder()(txBuilder.GetTx())
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := val.BroadcastTx(txBz)
+	out := bytes.NewBuffer(res)
+
+	return out, err
 }

testutil/network/network.go

@@ -52,6 +52,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	txtypes "github.com/cosmos/cosmos-sdk/types/tx"
 	_ "github.com/cosmos/cosmos-sdk/x/auth"           // import auth as a blank
 	_ "github.com/cosmos/cosmos-sdk/x/auth/tx/config" // import auth tx config as a blank
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
@@ -327,6 +328,19 @@ func (v Validator) GetAppConfig() *srvconfig.Config {
 	return v.AppConfig
 }
 
+func (v Validator) BroadcastTx(txBytes []byte) ([]byte, error) {
+	txReq := &txtypes.BroadcastTxRequest{
+		Mode:    txtypes.BroadcastMode_BROADCAST_MODE_SYNC,
+		TxBytes: txBytes,
+	}
+	req, err := v.ClientCtx.Codec.MarshalJSON(txReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return testutil.PostRequest(fmt.Sprintf("%s/cosmos/tx/v1beta1/txs", v.APIAddress), "application/json", req)
+}
+
 // CLILogger wraps a cobra.Command and provides command logging methods.
 type CLILogger struct {
 	cmd *cobra.Command