chore: gofumpt (#11839)

* fumpt using main not master...

* be more descriptive

* fumpt

* fix nits

Co-authored-by: Julien Robert <julien@rbrt.fr>

types/address.go

@@ -118,8 +118,11 @@ type Address interface {
 
 // Ensure that different address types implement the interface
 var _ Address = AccAddress{}
-var _ Address = ValAddress{}
-var _ Address = ConsAddress{}
+
+var (
+	_ Address = ValAddress{}
+	_ Address = ConsAddress{}
+)
 
 // ----------------------------------------------------------------------------
 // account
@@ -223,7 +226,6 @@ func (aa AccAddress) MarshalYAML() (interface{}, error) {
 func (aa *AccAddress) UnmarshalJSON(data []byte) error {
 	var s string
 	err := json.Unmarshal(data, &s)
-
 	if err != nil {
 		return err
 	}
@@ -273,7 +275,7 @@ func (aa AccAddress) String() string {
 		return ""
 	}
 
-	var key = conv.UnsafeBytesToStr(aa)
+	key := conv.UnsafeBytesToStr(aa)
 	accAddrMu.Lock()
 	defer accAddrMu.Unlock()
 	addr, ok := accAddrCache.Get(key)
@@ -423,7 +425,7 @@ func (va ValAddress) String() string {
 		return ""
 	}
 
-	var key = conv.UnsafeBytesToStr(va)
+	key := conv.UnsafeBytesToStr(va)
 	valAddrMu.Lock()
 	defer valAddrMu.Unlock()
 	addr, ok := valAddrCache.Get(key)
@@ -578,7 +580,7 @@ func (ca ConsAddress) String() string {
 		return ""
 	}
 
-	var key = conv.UnsafeBytesToStr(ca)
+	key := conv.UnsafeBytesToStr(ca)
 	consAddrMu.Lock()
 	defer consAddrMu.Unlock()
 	addr, ok := consAddrCache.Get(key)

types/address/hash_test.go

@@ -63,7 +63,7 @@ func (suite *AddressSuite) TestComposed() {
 
 func (suite *AddressSuite) TestModule() {
 	assert := suite.Assert()
-	var modName, key = "myModule", []byte{1, 2}
+	modName, key := "myModule", []byte{1, 2}
 	addr := Module(modName, key)
 	assert.Len(addr, Len, "must have address length")
 
@@ -77,7 +77,7 @@ func (suite *AddressSuite) TestModule() {
 
 func (suite *AddressSuite) TestDerive() {
 	assert := suite.Assert()
-	var addr, key1, key2 = []byte{1, 2}, []byte{3, 4}, []byte{1, 2}
+	addr, key1, key2 := []byte{1, 2}, []byte{3, 4}, []byte{1, 2}
 	d1 := Derive(addr, key1)
 	d2 := Derive(addr, key2)
 	d3 := Derive(key1, key2)

types/address_test.go

@@ -298,7 +298,6 @@ func (s *addressTestSuite) TestAddressInterface() {
 			s.T().Fail()
 		}
 	}
-
 }
 
 func (s *addressTestSuite) TestVerifyAddressFormat() {

types/bench_test.go

@@ -30,7 +30,7 @@ func BenchmarkParseCoin(b *testing.B) {
 }
 
 func BenchmarkUintMarshal(b *testing.B) {
-	var values = []uint64{
+	values := []uint64{
 		0,
 		1,
 		1 << 10,
@@ -55,7 +55,7 @@ func BenchmarkUintMarshal(b *testing.B) {
 }
 
 func BenchmarkIntMarshal(b *testing.B) {
-	var values = []int64{
+	values := []int64{
 		0,
 		1,
 		1 << 10,

types/coin_test.go

@@ -108,7 +108,6 @@ func (s *coinTestSuite) TestCoinIsValid() {
 }
 
 func (s *coinTestSuite) TestCustomValidation() {
-
 	newDnmRegex := `[\x{1F600}-\x{1F6FF}]`
 	sdk.SetCoinDenomRegex(func() string {
 		return newDnmRegex
@@ -739,7 +738,8 @@ func (s *coinTestSuite) TestCoins_Validate() {
 				{"mineral", sdk.OneInt()},
 			},
 			false,
-		}, {
+		},
+		{
 			"duplicate denomination",
 			sdk.Coins{
 				{"gas", sdk.OneInt()},
@@ -775,8 +775,13 @@ func (s *coinTestSuite) TestMinMax() {
 		{"zero-one", sdk.Coins{}, sdk.Coins{{testDenom1, one}}, sdk.Coins{}, sdk.Coins{{testDenom1, one}}},
 		{"two-zero", sdk.Coins{{testDenom2, two}}, sdk.Coins{}, sdk.Coins{}, sdk.Coins{{testDenom2, two}}},
 		{"disjoint", sdk.Coins{{testDenom1, one}}, sdk.Coins{{testDenom2, two}}, sdk.Coins{}, sdk.Coins{{testDenom1, one}, {testDenom2, two}}},
-		{"overlap", sdk.Coins{{testDenom1, one}, {testDenom2, two}}, sdk.Coins{{testDenom1, two}, {testDenom2, one}},
-			sdk.Coins{{testDenom1, one}, {testDenom2, one}}, sdk.Coins{{testDenom1, two}, {testDenom2, two}}},
+		{
+			"overlap",
+			sdk.Coins{{testDenom1, one}, {testDenom2, two}},
+			sdk.Coins{{testDenom1, two}, {testDenom2, one}},
+			sdk.Coins{{testDenom1, one}, {testDenom2, one}},
+			sdk.Coins{{testDenom1, two}, {testDenom2, two}},
+		},
 	}
 
 	for _, tc := range cases {
@@ -1126,7 +1131,6 @@ func (s *coinTestSuite) TestCoinsIsAnyNil() {
 	s.Require().True(sdk.Coins{twoAtom, nilAtom, fiveAtom, threeEth}.IsAnyNil())
 	s.Require().True(sdk.Coins{nilAtom, twoAtom, fiveAtom, threeEth}.IsAnyNil())
 	s.Require().False(sdk.Coins{twoAtom, fiveAtom, threeEth}.IsAnyNil())
-
 }
 
 func (s *coinTestSuite) TestMarshalJSONCoins() {

types/context.go

@@ -61,7 +61,7 @@ func (c Context) EventManager() *EventManager { return c.eventManager }
 
 // clone the header before returning
 func (c Context) BlockHeader() tmproto.Header {
-	var msg = proto.Clone(&c.header).(*tmproto.Header)
+	msg := proto.Clone(&c.header).(*tmproto.Header)
 	return *msg
 }
 

types/dec_coin_test.go

@@ -399,7 +399,8 @@ func (s *decCoinTestSuite) TestParseDecCoins() {
 			},
 			false,
 		},
-		{"0.0stake,0.004stake,5.04atom", // remove zero coins
+		{
+			"0.0stake,0.004stake,5.04atom", // remove zero coins
 			sdk.DecCoins{
 				sdk.NewDecCoinFromDec("atom", sdk.NewDecWithPrec(5040000000000000000, sdk.Precision)),
 				sdk.NewDecCoinFromDec("stake", sdk.NewDecWithPrec(4000000000000000, sdk.Precision)),
@@ -644,7 +645,8 @@ func (s *decCoinTestSuite) TestDecCoins_GetDenomByIndex() {
 			sdk.DecCoins{
 				sdk.DecCoin{testDenom1, sdk.NewDec(5)},
 				sdk.DecCoin{testDenom2, sdk.NewDec(57)},
-			}, 1, testDenom2, false,
+			},
+			1, testDenom2, false,
 		},
 	}
 
@@ -710,7 +712,6 @@ func (s *decCoinTestSuite) TestDecCoin_IsLT() {
 		expectedResult bool
 		expectedPanic  bool
 	}{
-
 		{"Same Denom - Less than other coin", sdk.DecCoin{testDenom1, sdk.NewDec(3)}, sdk.DecCoin{testDenom1, sdk.NewDec(19)}, true, false},
 
 		{"Same Denom - Greater than other coin", sdk.DecCoin{testDenom1, sdk.NewDec(343340)}, sdk.DecCoin{testDenom1, sdk.NewDec(14)}, false, false},
@@ -748,7 +749,6 @@ func (s *decCoinTestSuite) TestDecCoin_IsGTE() {
 		expectedResult bool
 		expectedPanic  bool
 	}{
-
 		{"Same Denom - Less than other coin", sdk.DecCoin{testDenom1, sdk.NewDec(3)}, sdk.DecCoin{testDenom1, sdk.NewDec(19)}, false, false},
 
 		{"Same Denom - Greater than other coin", sdk.DecCoin{testDenom1, sdk.NewDec(343340)}, sdk.DecCoin{testDenom1, sdk.NewDec(14)}, true, false},
@@ -924,7 +924,6 @@ func (s *decCoinTestSuite) TestDecCoins_MulDecTruncate() {
 }
 
 func (s *decCoinTestSuite) TestDecCoins_QuoDec() {
-
 	testCases := []struct {
 		name           string
 		coins          sdk.DecCoins
@@ -985,22 +984,33 @@ func (s *decCoinTestSuite) TestDecCoin_IsEqual() {
 		expectedResult bool
 		expectedPanic  bool
 	}{
-
-		{"Different Denom Same Amount", sdk.DecCoin{testDenom1, sdk.NewDec(20)},
-			sdk.DecCoin{testDenom2, sdk.NewDec(20)},
-			false, true},
-
-		{"Different Denom Different Amount", sdk.DecCoin{testDenom1, sdk.NewDec(20)},
-			sdk.DecCoin{testDenom2, sdk.NewDec(10)},
-			false, true},
-
-		{"Same Denom Different Amount", sdk.DecCoin{testDenom1, sdk.NewDec(20)},
-			sdk.DecCoin{testDenom1, sdk.NewDec(10)},
-			false, false},
-
-		{"Same Denom Same Amount", sdk.DecCoin{testDenom1, sdk.NewDec(20)},
+		{
+			"Different Denom Same Amount",
 			sdk.DecCoin{testDenom1, sdk.NewDec(20)},
-			true, false},
+			sdk.DecCoin{testDenom2, sdk.NewDec(20)},
+			false, true,
+		},
+
+		{
+			"Different Denom Different Amount",
+			sdk.DecCoin{testDenom1, sdk.NewDec(20)},
+			sdk.DecCoin{testDenom2, sdk.NewDec(10)},
+			false, true,
+		},
+
+		{
+			"Same Denom Different Amount",
+			sdk.DecCoin{testDenom1, sdk.NewDec(20)},
+			sdk.DecCoin{testDenom1, sdk.NewDec(10)},
+			false, false,
+		},
+
+		{
+			"Same Denom Same Amount",
+			sdk.DecCoin{testDenom1, sdk.NewDec(20)},
+			sdk.DecCoin{testDenom1, sdk.NewDec(20)},
+			true, false,
+		},
 	}
 
 	for i, tc := range testCases {

types/decimal_test.go

@@ -78,10 +78,14 @@ func (s *decimalTestSuite) TestNewDecFromStr() {
 		{"0.8", false, sdk.NewDecWithPrec(8, 1)},
 		{"0.11111", false, sdk.NewDecWithPrec(11111, 5)},
 		{"314460551102969.3144278234343371835", true, sdk.NewDec(3141203149163817869)},
-		{"314460551102969314427823434337.1835718092488231350",
-			true, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4)},
-		{"314460551102969314427823434337.1835",
-			false, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4)},
+		{
+			"314460551102969314427823434337.1835718092488231350",
+			true, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4),
+		},
+		{
+			"314460551102969314427823434337.1835",
+			false, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4),
+		},
 		{".", true, sdk.Dec{}},
 		{".0", true, sdk.NewDec(0)},
 		{"1.", true, sdk.NewDec(1)},
@@ -189,7 +193,6 @@ func (s *decimalTestSuite) TestEqualities() {
 		s.Require().Equal(tc.lt, tc.d1.LT(tc.d2), "LT result is incorrect, tc %d", tcIndex)
 		s.Require().Equal(tc.eq, tc.d1.Equal(tc.d2), "equality result is incorrect, tc %d", tcIndex)
 	}
-
 }
 
 func (s *decimalTestSuite) TestDecsEqual() {
@@ -233,19 +236,27 @@ func (s *decimalTestSuite) TestArithmetic() {
 		{sdk.NewDec(1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(2)},
 		{sdk.NewDec(-1), sdk.NewDec(1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(-2)},
 
-		{sdk.NewDec(3), sdk.NewDec(7), sdk.NewDec(21), sdk.NewDec(21),
+		{
+			sdk.NewDec(3), sdk.NewDec(7), sdk.NewDec(21), sdk.NewDec(21),
 			sdk.NewDecWithPrec(428571428571428571, 18), sdk.NewDecWithPrec(428571428571428572, 18), sdk.NewDecWithPrec(428571428571428571, 18),
-			sdk.NewDec(10), sdk.NewDec(-4)},
-		{sdk.NewDec(2), sdk.NewDec(4), sdk.NewDec(8), sdk.NewDec(8), sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1),
-			sdk.NewDec(6), sdk.NewDec(-2)},
+			sdk.NewDec(10), sdk.NewDec(-4),
+		},
+		{
+			sdk.NewDec(2), sdk.NewDec(4), sdk.NewDec(8), sdk.NewDec(8), sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1),
+			sdk.NewDec(6), sdk.NewDec(-2),
+		},
 
 		{sdk.NewDec(100), sdk.NewDec(100), sdk.NewDec(10000), sdk.NewDec(10000), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(200), sdk.NewDec(0)},
 
-		{sdk.NewDecWithPrec(15, 1), sdk.NewDecWithPrec(15, 1), sdk.NewDecWithPrec(225, 2), sdk.NewDecWithPrec(225, 2),
-			sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(3), sdk.NewDec(0)},
-		{sdk.NewDecWithPrec(3333, 4), sdk.NewDecWithPrec(333, 4), sdk.NewDecWithPrec(1109889, 8), sdk.NewDecWithPrec(1109889, 8),
+		{
+			sdk.NewDecWithPrec(15, 1), sdk.NewDecWithPrec(15, 1), sdk.NewDecWithPrec(225, 2), sdk.NewDecWithPrec(225, 2),
+			sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(3), sdk.NewDec(0),
+		},
+		{
+			sdk.NewDecWithPrec(3333, 4), sdk.NewDecWithPrec(333, 4), sdk.NewDecWithPrec(1109889, 8), sdk.NewDecWithPrec(1109889, 8),
 			sdk.MustNewDecFromStr("10.009009009009009009"), sdk.MustNewDecFromStr("10.009009009009009010"), sdk.MustNewDecFromStr("10.009009009009009009"),
-			sdk.NewDecWithPrec(3666, 4), sdk.NewDecWithPrec(3, 1)},
+			sdk.NewDecWithPrec(3666, 4), sdk.NewDecWithPrec(3, 1),
+		},
 	}
 
 	for tcIndex, tc := range tests {

types/module/module.go

@@ -226,7 +226,6 @@ type Manager struct {
 
 // NewManager creates a new Manager object
 func NewManager(modules ...AppModule) *Manager {
-
 	moduleMap := make(map[string]AppModule)
 	modulesStr := make([]string, 0, len(modules))
 	for _, module := range modules {
@@ -422,7 +421,7 @@ func (m Manager) RunMigrations(ctx sdk.Context, cfg Configurator, fromVM Version
 	if !ok {
 		return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expected %T, got %T", configurator{}, cfg)
 	}
-	var modules = m.OrderMigrations
+	modules := m.OrderMigrations
 	if modules == nil {
 		modules = DefaultMigrationsOrder(m.ModuleNames())
 	}

types/module/module_test.go

@@ -209,7 +209,8 @@ func TestManager_InitGenesis(t *testing.T) {
 	// test panic
 	genesisData = map[string]json.RawMessage{
 		"module1": json.RawMessage(`{"key": "value"}`),
-		"module2": json.RawMessage(`{"key": "value"}`)}
+		"module2": json.RawMessage(`{"key": "value"}`),
+	}
 	mockAppModule1.EXPECT().InitGenesis(gomock.Eq(ctx), gomock.Eq(cdc), gomock.Eq(genesisData["module1"])).Times(1).Return([]abci.ValidatorUpdate{{}})
 	mockAppModule2.EXPECT().InitGenesis(gomock.Eq(ctx), gomock.Eq(cdc), gomock.Eq(genesisData["module2"])).Times(1).Return([]abci.ValidatorUpdate{{}})
 	require.Panics(t, func() { mm.InitGenesis(ctx, cdc, genesisData) })
@@ -235,7 +236,8 @@ func TestManager_ExportGenesis(t *testing.T) {
 
 	want := map[string]json.RawMessage{
 		"module1": json.RawMessage(`{"key1": "value1"}`),
-		"module2": json.RawMessage(`{"key2": "value2"}`)}
+		"module2": json.RawMessage(`{"key2": "value2"}`),
+	}
 	require.Equal(t, want, mm.ExportGenesis(ctx, cdc))
 }
 

types/module/simulation.go

@@ -2,7 +2,6 @@ package module
 
 import (
 	"encoding/json"
-
 	"math/rand"
 	"time"
 

types/query/filtered_pagination.go

@@ -19,7 +19,6 @@ func FilteredPaginate(
 	pageRequest *PageRequest,
 	onResult func(key []byte, value []byte, accumulate bool) (bool, error),
 ) (*PageResponse, error) {
-
 	// if the PageRequest is nil, use default PageRequest
 	if pageRequest == nil {
 		pageRequest = &PageRequest{}

types/query/filtered_pagination_test.go

@@ -168,7 +168,6 @@ func (s *paginationTestSuite) TestReverseFilteredPaginations() {
 
 	s.T().Log("verify Reverse pagination returns valid result")
 	s.Require().Equal(balances[235:241].String(), balns.Sort().String())
-
 }
 
 func ExampleFilteredPaginate(t *testing.T) {
@@ -218,7 +217,6 @@ func ExampleFilteredPaginate(t *testing.T) {
 
 		return false, nil
 	})
-
 	if err != nil { // should return no error
 		fmt.Println(err)
 	}

types/query/pagination.go

@@ -54,7 +54,6 @@ func Paginate(
 	pageRequest *PageRequest,
 	onResult func(key []byte, value []byte) error,
 ) (*PageResponse, error) {
-
 	// if the PageRequest is nil, use default PageRequest
 	if pageRequest == nil {
 		pageRequest = &PageRequest{}

types/simulation/rand_util.go

@@ -53,7 +53,7 @@ func RandPositiveInt(r *rand.Rand, max sdk.Int) (sdk.Int, error) {
 // RandomAmount generates a random amount
 // Note: The range of RandomAmount includes max, and is, in fact, biased to return max as well as 0.
 func RandomAmount(r *rand.Rand, max sdk.Int) sdk.Int {
-	var randInt = big.NewInt(0)
+	randInt := big.NewInt(0)
 
 	switch r.Intn(10) {
 	case 0:
@@ -70,7 +70,7 @@ func RandomAmount(r *rand.Rand, max sdk.Int) sdk.Int {
 // RandomDecAmount generates a random decimal amount
 // Note: The range of RandomDecAmount includes max, and is, in fact, biased to return max as well as 0.
 func RandomDecAmount(r *rand.Rand, max sdk.Dec) sdk.Dec {
-	var randInt = big.NewInt(0)
+	randInt := big.NewInt(0)
 
 	switch r.Intn(10) {
 	case 0:

types/simulation/types.go

@@ -84,7 +84,6 @@ func NewOperationMsg(msg sdk.Msg, ok bool, comment string, cdc *codec.ProtoCodec
 	bz := cdc.MustMarshalJSON(msg)
 
 	return NewOperationMsgBasic(sdk.MsgTypeURL(msg), sdk.MsgTypeURL(msg), comment, ok, bz)
-
 }
 
 // NoOpMsg - create a no-operation message

types/store_internal_test.go

@@ -16,7 +16,7 @@ func TestStoreIntSuite(t *testing.T) {
 }
 
 func (s *storeIntSuite) TestAssertNoPrefix() {
-	var testCases = []struct {
+	testCases := []struct {
 		keys        []string
 		expectPanic bool
 	}{

types/store_test.go

@@ -25,7 +25,7 @@ func (s *storeTestSuite) SetupSuite() {
 }
 
 func (s *storeTestSuite) TestPrefixEndBytes() {
-	var testCases = []struct {
+	testCases := []struct {
 		prefix   []byte
 		expected []byte
 	}{
@@ -48,7 +48,7 @@ func (s *storeTestSuite) TestCommitID() {
 	var empty types.CommitID
 	s.Require().True(empty.IsZero())
 
-	var nonempty = types.CommitID{
+	nonempty := types.CommitID{
 		Version: 1,
 		Hash:    []byte("testhash"),
 	}

types/tx/signing/signature.go

@@ -92,7 +92,6 @@ var _, _ codectypes.UnpackInterfacesMessage = &SignatureDescriptors{}, &Signatur
 func (sds *SignatureDescriptors) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
 	for _, sig := range sds.Signatures {
 		err := sig.UnpackInterfaces(unpacker)
-
 		if err != nil {
 			return err
 		}

types/tx/types.go

@@ -128,9 +128,11 @@ func (t *Tx) GetSigners() []sdk.AccAddress {
 func (t *Tx) GetGas() uint64 {
 	return t.AuthInfo.Fee.GasLimit
 }
+
 func (t *Tx) GetFee() sdk.Coins {
 	return t.AuthInfo.Fee.Amount
 }
+
 func (t *Tx) FeePayer() sdk.AccAddress {
 	feePayer := t.AuthInfo.Fee.Payer
 	if feePayer != "" {

types/utils_test.go

@@ -30,20 +30,28 @@ func (s *utilsTestSuite) TestSortJSON() {
 		wantErr      bool
 	}{
 		// simple case
-		{unsortedJSON: `{"cosmos":"foo", "atom":"bar",  "tendermint":"foobar"}`,
-			want: `{"atom":"bar","cosmos":"foo","tendermint":"foobar"}`, wantErr: false},
+		{
+			unsortedJSON: `{"cosmos":"foo", "atom":"bar",  "tendermint":"foobar"}`,
+			want:         `{"atom":"bar","cosmos":"foo","tendermint":"foobar"}`, wantErr: false,
+		},
 		// failing case (invalid JSON):
-		{unsortedJSON: `"cosmos":"foo",,,, "atom":"bar",  "tendermint":"foobar"}`,
-			want:    "",
-			wantErr: true},
+		{
+			unsortedJSON: `"cosmos":"foo",,,, "atom":"bar",  "tendermint":"foobar"}`,
+			want:         "",
+			wantErr:      true,
+		},
 		// genesis.json
-		{unsortedJSON: `{"consensus_params":{"block_size_params":{"max_bytes":22020096,"max_txs":100000,"max_gas":-1},"tx_size_params":{"max_bytes":10240,"max_gas":-1},"block_gossip_params":{"block_part_size_bytes":65536},"evidence_params":{"max_age":100000}},"validators":[{"pub_key":{"type":"AC26791624DE60","value":"c7UMMAbjFuc5GhGPy0E5q5tefy12p9Tq0imXqdrKXwo="},"power":100,"name":""}],"app_hash":"","genesis_time":"2018-05-11T15:52:25.424795506Z","chain_id":"test-chain-Q6VeoW","app_state":{"accounts":[{"address":"718C9C23F98C9642569742ADDD9F9AB9743FBD5D","coins":[{"denom":"Token","amount":1000},{"denom":"stake","amount":50}]}],"stake":{"pool":{"total_supply":50,"bonded_shares":"0","unbonded_shares":"0","bonded_pool":0,"unbonded_pool":0,"inflation_last_time":0,"inflation":"7/100"},"params":{"inflation_rate_change":"13/100","inflation_max":"1/5","inflation_min":"7/100","goal_bonded":"67/100","max_validators":100,"bond_denom":"stake"},"candidates":null,"bonds":null}}}`,
-			want:    `{"app_hash":"","app_state":{"accounts":[{"address":"718C9C23F98C9642569742ADDD9F9AB9743FBD5D","coins":[{"amount":1000,"denom":"Token"},{"amount":50,"denom":"stake"}]}],"stake":{"bonds":null,"candidates":null,"params":{"bond_denom":"stake","goal_bonded":"67/100","inflation_max":"1/5","inflation_min":"7/100","inflation_rate_change":"13/100","max_validators":100},"pool":{"bonded_pool":0,"bonded_shares":"0","inflation":"7/100","inflation_last_time":0,"total_supply":50,"unbonded_pool":0,"unbonded_shares":"0"}}},"chain_id":"test-chain-Q6VeoW","consensus_params":{"block_gossip_params":{"block_part_size_bytes":65536},"block_size_params":{"max_bytes":22020096,"max_gas":-1,"max_txs":100000},"evidence_params":{"max_age":100000},"tx_size_params":{"max_bytes":10240,"max_gas":-1}},"genesis_time":"2018-05-11T15:52:25.424795506Z","validators":[{"name":"","power":100,"pub_key":{"type":"AC26791624DE60","value":"c7UMMAbjFuc5GhGPy0E5q5tefy12p9Tq0imXqdrKXwo="}}]}`,
-			wantErr: false},
+		{
+			unsortedJSON: `{"consensus_params":{"block_size_params":{"max_bytes":22020096,"max_txs":100000,"max_gas":-1},"tx_size_params":{"max_bytes":10240,"max_gas":-1},"block_gossip_params":{"block_part_size_bytes":65536},"evidence_params":{"max_age":100000}},"validators":[{"pub_key":{"type":"AC26791624DE60","value":"c7UMMAbjFuc5GhGPy0E5q5tefy12p9Tq0imXqdrKXwo="},"power":100,"name":""}],"app_hash":"","genesis_time":"2018-05-11T15:52:25.424795506Z","chain_id":"test-chain-Q6VeoW","app_state":{"accounts":[{"address":"718C9C23F98C9642569742ADDD9F9AB9743FBD5D","coins":[{"denom":"Token","amount":1000},{"denom":"stake","amount":50}]}],"stake":{"pool":{"total_supply":50,"bonded_shares":"0","unbonded_shares":"0","bonded_pool":0,"unbonded_pool":0,"inflation_last_time":0,"inflation":"7/100"},"params":{"inflation_rate_change":"13/100","inflation_max":"1/5","inflation_min":"7/100","goal_bonded":"67/100","max_validators":100,"bond_denom":"stake"},"candidates":null,"bonds":null}}}`,
+			want:         `{"app_hash":"","app_state":{"accounts":[{"address":"718C9C23F98C9642569742ADDD9F9AB9743FBD5D","coins":[{"amount":1000,"denom":"Token"},{"amount":50,"denom":"stake"}]}],"stake":{"bonds":null,"candidates":null,"params":{"bond_denom":"stake","goal_bonded":"67/100","inflation_max":"1/5","inflation_min":"7/100","inflation_rate_change":"13/100","max_validators":100},"pool":{"bonded_pool":0,"bonded_shares":"0","inflation":"7/100","inflation_last_time":0,"total_supply":50,"unbonded_pool":0,"unbonded_shares":"0"}}},"chain_id":"test-chain-Q6VeoW","consensus_params":{"block_gossip_params":{"block_part_size_bytes":65536},"block_size_params":{"max_bytes":22020096,"max_gas":-1,"max_txs":100000},"evidence_params":{"max_age":100000},"tx_size_params":{"max_bytes":10240,"max_gas":-1}},"genesis_time":"2018-05-11T15:52:25.424795506Z","validators":[{"name":"","power":100,"pub_key":{"type":"AC26791624DE60","value":"c7UMMAbjFuc5GhGPy0E5q5tefy12p9Tq0imXqdrKXwo="}}]}`,
+			wantErr:      false,
+		},
 		// from the TXSpec:
-		{unsortedJSON: `{"chain_id":"test-chain-1","sequence":1,"fee_bytes":{"amount":[{"amount":5,"denom":"photon"}],"gas":10000},"msg_bytes":{"inputs":[{"address":"696E707574","coins":[{"amount":10,"denom":"atom"}]}],"outputs":[{"address":"6F7574707574","coins":[{"amount":10,"denom":"atom"}]}]},"alt_bytes":null}`,
-			want:    `{"alt_bytes":null,"chain_id":"test-chain-1","fee_bytes":{"amount":[{"amount":5,"denom":"photon"}],"gas":10000},"msg_bytes":{"inputs":[{"address":"696E707574","coins":[{"amount":10,"denom":"atom"}]}],"outputs":[{"address":"6F7574707574","coins":[{"amount":10,"denom":"atom"}]}]},"sequence":1}`,
-			wantErr: false},
+		{
+			unsortedJSON: `{"chain_id":"test-chain-1","sequence":1,"fee_bytes":{"amount":[{"amount":5,"denom":"photon"}],"gas":10000},"msg_bytes":{"inputs":[{"address":"696E707574","coins":[{"amount":10,"denom":"atom"}]}],"outputs":[{"address":"6F7574707574","coins":[{"amount":10,"denom":"atom"}]}]},"alt_bytes":null}`,
+			want:         `{"alt_bytes":null,"chain_id":"test-chain-1","fee_bytes":{"amount":[{"amount":5,"denom":"photon"}],"gas":10000},"msg_bytes":{"inputs":[{"address":"696E707574","coins":[{"amount":10,"denom":"atom"}]}],"outputs":[{"address":"6F7574707574","coins":[{"amount":10,"denom":"atom"}]}]},"sequence":1}`,
+			wantErr:      false,
+		},
 	}
 
 	for tcIndex, tc := range cases {