R4R: Add fees and memo to REST, updated CLI to receive coins as fees

client/flags.go

@@ -77,7 +77,7 @@ func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 		c.Flags().Uint64(FlagAccountNumber, 0, "AccountNumber number to sign the tx")
 		c.Flags().Uint64(FlagSequence, 0, "Sequence number to sign the tx")
 		c.Flags().String(FlagMemo, "", "Memo to send along with transaction")
-		c.Flags().String(FlagFee, "", "Fee to pay along with transaction")
+		c.Flags().String(FlagFee, "", "fees to pay along with transaction; eg: 10stake,1atom")
 		c.Flags().String(FlagChainID, "", "Chain ID of tendermint node")
 		c.Flags().String(FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
 		c.Flags().Bool(FlagUseLedger, false, "Use a connected Ledger device")

client/lcd/swagger-ui/swagger.yaml

@@ -1871,23 +1871,32 @@ definitions:
     properties:
       name:
         type: string
+        example: "my_name"
       password:
         type: string
         example: "12345678"
+      memo:
+        type: string
+        example: "Sent via Cosmos Voyager 🚀"
       chain_id:
         type: string
+        example: "Cosmos-Hub"
       account_number:
-        type: string
-        example: "0"
+        type: integer
+        example: 0
       sequence:
-        type: string
-        example: "0"
+        type: integer
+        example: 1
       gas:
         type: string
         example: "200000"
       gas_adjustment:
         type: string
         example: "1.2"
+      fees:
+        type: array
+        items:
+          $ref: "#/definitions/Coin"
   TendermintValidator:
     type: object
     properties:

client/utils/rest.go

@@ -121,25 +121,29 @@ func urlQueryHasArg(url *url.URL, arg string) bool { return url.Query().Get(arg)
 // BaseReq defines a structure that can be embedded in other request structures
 // that all share common "base" fields.
 type BaseReq struct {
-	Name          string `json:"name"`
-	Password      string `json:"password"`
-	ChainID       string `json:"chain_id"`
-	AccountNumber uint64 `json:"account_number"`
-	Sequence      uint64 `json:"sequence"`
-	Gas           string `json:"gas"`
-	GasAdjustment string `json:"gas_adjustment"`
+	Name          string    `json:"name"`
+	Password      string    `json:"password"`
+	Memo          string    `json:"memo"`
+	ChainID       string    `json:"chain_id"`
+	AccountNumber uint64    `json:"account_number"`
+	Sequence      uint64    `json:"sequence"`
+	Gas           string    `json:"gas"`
+	GasAdjustment string    `json:"gas_adjustment"`
+	Fees          sdk.Coins `json:"fees"`
 }
 
 // Sanitize performs basic sanitization on a BaseReq object.
 func (br BaseReq) Sanitize() BaseReq {
 	return BaseReq{
 		Name:          strings.TrimSpace(br.Name),
 		Password:      strings.TrimSpace(br.Password),
+		Memo:          strings.TrimSpace(br.Memo),
 		ChainID:       strings.TrimSpace(br.ChainID),
 		Gas:           strings.TrimSpace(br.Gas),
 		GasAdjustment: strings.TrimSpace(br.GasAdjustment),
 		AccountNumber: br.AccountNumber,
 		Sequence:      br.Sequence,
+		Fees:          br.Fees,
 	}
 }
 
@@ -188,6 +192,10 @@ func (br BaseReq) ValidateBasic(w http.ResponseWriter) bool {
 	case len(br.ChainID) == 0:
 		WriteErrorResponse(w, http.StatusUnauthorized, "chainID required but not specified")
 		return false
+
+	case !br.Fees.IsValid():
+		WriteErrorResponse(w, http.StatusPaymentRequired, sdk.ErrInvalidCoins("").Error())
+		return false
 	}
 
 	return true
@@ -213,15 +221,7 @@ func CompleteAndBroadcastTxREST(w http.ResponseWriter, r *http.Request, cliCtx c
 		return
 	}
 
-	txBldr := authtxb.TxBuilder{
-		Codec:         cdc,
-		Gas:           gas,
-		GasAdjustment: adjustment,
-		SimulateGas:   simulateGas,
-		ChainID:       baseReq.ChainID,
-		AccountNumber: baseReq.AccountNumber,
-		Sequence:      baseReq.Sequence,
-	}
+	txBldr := authtxb.NewTxBuilder(cdc, baseReq.AccountNumber, baseReq.Sequence, gas, adjustment, simulateGas, baseReq.ChainID, baseReq.Memo, baseReq.Fees)
 
 	if HasDryRunArg(r) || txBldr.SimulateGas {
 		newBldr, err := EnrichCtxWithGas(txBldr, cliCtx, baseReq.Name, msgs)

cmd/gaia/app/benchmarks/txsize_test.go

@@ -21,12 +21,12 @@ func ExampleTxSendSize() {
 	addr1 := sdk.AccAddress(priv1.PubKey().Address())
 	priv2 := secp256k1.GenPrivKeySecp256k1([]byte{1})
 	addr2 := sdk.AccAddress(priv2.PubKey().Address())
-	coins := []sdk.Coin{sdk.NewCoin("denom", sdk.NewInt(10))}
+	coins := sdk.Coins{sdk.NewCoin("denom", sdk.NewInt(10))}
 	msg1 := bank.MsgSend{
 		Inputs:  []bank.Input{bank.NewInput(addr1, coins)},
 		Outputs: []bank.Output{bank.NewOutput(addr2, coins)},
 	}
-	fee := auth.NewStdFee(gas, coins...)
+	fee := auth.NewStdFee(gas, coins)
 	signBytes := auth.StdSignBytes("example-chain-ID",
 		1, 1, fee, []sdk.Msg{msg1}, "")
 	sig, _ := priv1.Sign(signBytes)

x/auth/ante_test.go

@@ -22,7 +22,7 @@ func newTestMsg(addrs ...sdk.AccAddress) *sdk.TestMsg {
 
 func newStdFee() StdFee {
 	return NewStdFee(50000,
-		sdk.NewInt64Coin("atom", 150),
+		sdk.Coins{sdk.NewInt64Coin("atom", 150)},
 	)
 }
 
@@ -426,24 +426,24 @@ func TestAnteHandlerMemoGas(t *testing.T) {
 	var tx sdk.Tx
 	msg := newTestMsg(addr1)
 	privs, accnums, seqs := []crypto.PrivKey{priv1}, []uint64{0}, []uint64{0}
-	fee := NewStdFee(0, sdk.NewInt64Coin("atom", 0))
+	fee := NewStdFee(0, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
 
 	// tx does not have enough gas
 	tx = newTestTx(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee)
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeOutOfGas)
 
 	// tx with memo doesn't have enough gas
-	fee = NewStdFee(801, sdk.NewInt64Coin("atom", 0))
+	fee = NewStdFee(801, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
 	tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeOutOfGas)
 
 	// memo too large
-	fee = NewStdFee(9000, sdk.NewInt64Coin("atom", 0))
+	fee = NewStdFee(9000, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
 	tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, strings.Repeat("01234567890", 500))
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeMemoTooLarge)
 
 	// tx with memo has enough gas
-	fee = NewStdFee(9000, sdk.NewInt64Coin("atom", 0))
+	fee = NewStdFee(9000, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
 	tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, strings.Repeat("0123456789", 10))
 	checkValidTx(t, anteHandler, ctx, tx, false)
 }

x/auth/client/txbuilder/txbuilder.go

@@ -1,6 +1,8 @@
 package context
 
 import (
+	"fmt"
+
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -21,7 +23,31 @@ type TxBuilder struct {
 	SimulateGas   bool
 	ChainID       string
 	Memo          string
-	Fee           string
+	Fees          sdk.Coins
+}
+
+// NewTxBuilder returns a new initialized TxBuilder
+func NewTxBuilder(cdc *codec.Codec, accNumber, seq, gas uint64, gasAdj float64, simulate bool, chainID, memo string, fees sdk.Coins) TxBuilder {
+	// if chain ID is not specified manually, read default chain ID
+	if chainID == "" {
+		defaultChainID, err := sdk.DefaultChainID()
+		if err != nil {
+			panic(err)
+		}
+		chainID = defaultChainID
+	}
+
+	return TxBuilder{
+		Codec:         cdc,
+		ChainID:       chainID,
+		AccountNumber: accNumber,
+		Gas:           gas,
+		GasAdjustment: gasAdj,
+		Sequence:      seq,
+		SimulateGas:   simulate,
+		Fees:          fees,
+		Memo:          memo,
+	}
 }
 
 // NewTxBuilderFromCLI returns a new initialized TxBuilder with parameters from
@@ -32,8 +58,14 @@ func NewTxBuilderFromCLI() TxBuilder {
 	if chainID == "" {
 		defaultChainID, err := sdk.DefaultChainID()
 		if err != nil {
-			chainID = defaultChainID
+			panic(err)
 		}
+		chainID = defaultChainID
+	}
+	feesStr := viper.GetString(client.FlagFee)
+	parsedFees, err := sdk.ParseCoins(feesStr)
+	if err != nil {
+		panic(fmt.Sprintf("invalid coins: %s", feesStr))
 	}
 
 	return TxBuilder{
@@ -43,7 +75,7 @@ func NewTxBuilderFromCLI() TxBuilder {
 		GasAdjustment: viper.GetFloat64(client.FlagGasAdjustment),
 		Sequence:      uint64(viper.GetInt64(client.FlagSequence)),
 		SimulateGas:   client.GasFlagVar.Simulate,
-		Fee:           viper.GetString(client.FlagFee),
+		Fees:          parsedFees,
 		Memo:          viper.GetString(client.FlagMemo),
 	}
 }
@@ -67,8 +99,12 @@ func (bldr TxBuilder) WithGas(gas uint64) TxBuilder {
 }
 
 // WithFee returns a copy of the context with an updated fee.
-func (bldr TxBuilder) WithFee(fee string) TxBuilder {
-	bldr.Fee = fee
+func (bldr TxBuilder) WithFees(fee string) TxBuilder {
+	parsedFees, err := sdk.ParseCoins(fee)
+	if err != nil {
+		panic(fmt.Sprintf("invalid coins: %s", fee))
+	}
+	bldr.Fees = parsedFees
 	return bldr
 }
 
@@ -98,23 +134,13 @@ func (bldr TxBuilder) Build(msgs []sdk.Msg) (StdSignMsg, error) {
 		return StdSignMsg{}, errors.Errorf("chain ID required but not specified")
 	}
 
-	fee := sdk.Coin{}
-	if bldr.Fee != "" {
-		parsedFee, err := sdk.ParseCoin(bldr.Fee)
-		if err != nil {
-			return StdSignMsg{}, err
-		}
-
-		fee = parsedFee
-	}
-
 	return StdSignMsg{
 		ChainID:       bldr.ChainID,
 		AccountNumber: bldr.AccountNumber,
 		Sequence:      bldr.Sequence,
 		Memo:          bldr.Memo,
 		Msgs:          msgs,
-		Fee:           auth.NewStdFee(bldr.Gas, fee),
+		Fee:           auth.NewStdFee(bldr.Gas, bldr.Fees),
 	}, nil
 }
 

x/auth/client/txbuilder/txbuilder_test.go

@@ -28,7 +28,7 @@ func TestTxBuilderBuild(t *testing.T) {
 		SimulateGas   bool
 		ChainID       string
 		Memo          string
-		Fee           string
+		Fees          sdk.Coins
 	}
 	defaultMsg := []sdk.Msg{sdk.NewTestMsg(addr)}
 	tests := []struct {
@@ -46,33 +46,23 @@ func TestTxBuilderBuild(t *testing.T) {
 				GasAdjustment: 1.1,
 				SimulateGas:   false,
 				ChainID:       "test-chain",
-				Memo:          "hello",
-				Fee:           "1" + stakeTypes.DefaultBondDenom,
+				Memo:          "hello from Voyager !",
+				Fees:          sdk.Coins{sdk.NewCoin(stakeTypes.DefaultBondDenom, sdk.NewInt(1))},
 			},
 			defaultMsg,
 			StdSignMsg{
 				ChainID:       "test-chain",
 				AccountNumber: 1,
 				Sequence:      1,
-				Memo:          "hello",
+				Memo:          "hello from Voyager !",
 				Msgs:          defaultMsg,
-				Fee:           auth.NewStdFee(100, sdk.NewCoin(stakeTypes.DefaultBondDenom, sdk.NewInt(1))),
+				Fee:           auth.NewStdFee(100, sdk.Coins{sdk.NewCoin(stakeTypes.DefaultBondDenom, sdk.NewInt(1))}),
 			},
 			false,
 		},
 	}
 	for i, tc := range tests {
-		bldr := TxBuilder{
-			Codec:         tc.fields.Codec,
-			AccountNumber: tc.fields.AccountNumber,
-			Sequence:      tc.fields.Sequence,
-			Gas:           tc.fields.Gas,
-			GasAdjustment: tc.fields.GasAdjustment,
-			SimulateGas:   tc.fields.SimulateGas,
-			ChainID:       tc.fields.ChainID,
-			Memo:          tc.fields.Memo,
-			Fee:           tc.fields.Fee,
-		}
+		bldr := NewTxBuilder(tc.fields.Codec, tc.fields.AccountNumber, tc.fields.Sequence, tc.fields.Gas, tc.fields.GasAdjustment, tc.fields.SimulateGas, tc.fields.ChainID, tc.fields.Memo, tc.fields.Fees)
 		got, err := bldr.Build(tc.msgs)
 		require.Equal(t, tc.wantErr, (err != nil), "TxBuilder.Build() error = %v, wantErr %v, tc %d", err, tc.wantErr, i)
 		if !reflect.DeepEqual(got, tc.want) {

x/auth/stdtx.go

@@ -125,7 +125,7 @@ type StdFee struct {
 	Gas    uint64    `json:"gas"`
 }
 
-func NewStdFee(gas uint64, amount ...sdk.Coin) StdFee {
+func NewStdFee(gas uint64, amount sdk.Coins) StdFee {
 	return StdFee{
 		Amount: amount,
 		Gas:    gas,

x/bank/app_test.go

@@ -43,7 +43,7 @@ var (
 	coins     = sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}
 	halfCoins = sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}
 	manyCoins = sdk.Coins{sdk.NewInt64Coin("foocoin", 1), sdk.NewInt64Coin("barcoin", 1)}
-	freeFee   = auth.NewStdFee(100000, sdk.Coins{sdk.NewInt64Coin("foocoin", 0)}...)
+	freeFee   = auth.NewStdFee(100000, sdk.Coins{sdk.NewInt64Coin("foocoin", 0)})
 
 	sendMsg1 = MsgSend{
 		Inputs:  []Input{NewInput(addr1, coins)},

x/stake/test_common.go

@@ -20,7 +20,7 @@ var (
 	coins = sdk.Coins{sdk.NewCoin("foocoin", sdk.NewInt(10))}
 	fee   = auth.NewStdFee(
 		100000,
-		sdk.Coins{sdk.NewCoin("foocoin", sdk.NewInt(0))}...,
+		sdk.Coins{sdk.NewCoin("foocoin", sdk.NewInt(0))},
 	)
 
 	commissionMsg = NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())