diff --git a/crypto/keys/multisig/codec.go b/crypto/keys/multisig/codec.go
index d76dc83ba1..c282d01227 100644
--- a/crypto/keys/multisig/codec.go
+++ b/crypto/keys/multisig/codec.go
@@ -1,11 +1,11 @@
 package multisig
 
 import (
-	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/sr25519"
 
 	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 )
diff --git a/types/address_test.go b/types/address_test.go
index a70cd11526..93a59a7a80 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -18,12 +18,12 @@ import (
 	"github.com/cosmos/cosmos-sdk/types"
 )
 
-type AddressTestSuite struct {
+type addressTestSuite struct {
 	suite.Suite
 }
 
 func TestAddressTestSuite(t *testing.T) {
-	suite.Run(t, new(AddressTestSuite))
+	suite.Run(t, new(addressTestSuite))
 }
 
 var invalidStrs = []string{
@@ -38,14 +38,14 @@ var invalidStrs = []string{
 	types.Bech32PrefixConsPub + "6789",
 }
 
-func (s *AddressTestSuite) testMarshal(original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) {
+func (s *addressTestSuite) testMarshal(original interface{}, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) {
 	bz, err := marshal()
 	s.Require().Nil(err)
 	s.Require().Nil(unmarshal(bz))
 	s.Require().Equal(original, res)
 }
 
-func (s *AddressTestSuite) TestEmptyAddresses() {
+func (s *addressTestSuite) TestEmptyAddresses() {
 	s.T().Parallel()
 	s.Require().Equal((types.AccAddress{}).String(), "")
 	s.Require().Equal((types.ValAddress{}).String(), "")
@@ -64,7 +64,7 @@ func (s *AddressTestSuite) TestEmptyAddresses() {
 	s.Require().Error(err)
 }
 
-func (s *AddressTestSuite) TestRandBech32PubkeyConsistency() {
+func (s *addressTestSuite) TestRandBech32PubkeyConsistency() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
 
@@ -106,7 +106,7 @@ func (s *AddressTestSuite) TestRandBech32PubkeyConsistency() {
 	}
 }
 
-func (s *AddressTestSuite) TestYAMLMarshalers() {
+func (s *addressTestSuite) TestYAMLMarshalers() {
 	addr := secp256k1.GenPrivKey().PubKey().Address()
 
 	acc := types.AccAddress(addr)
@@ -123,7 +123,7 @@ func (s *AddressTestSuite) TestYAMLMarshalers() {
 	s.Require().Equal(cons.String()+"\n", string(got))
 }
 
-func (s *AddressTestSuite) TestRandBech32AccAddrConsistency() {
+func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
 
@@ -162,7 +162,7 @@ func (s *AddressTestSuite) TestRandBech32AccAddrConsistency() {
 	s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error())
 }
 
-func (s *AddressTestSuite) TestValAddr() {
+func (s *addressTestSuite) TestValAddr() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
 
@@ -203,7 +203,7 @@ func (s *AddressTestSuite) TestValAddr() {
 	s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error())
 }
 
-func (s *AddressTestSuite) TestConsAddress() {
+func (s *addressTestSuite) TestConsAddress() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
 
@@ -253,7 +253,7 @@ func RandString(n int) string {
 	return string(b)
 }
 
-func (s *AddressTestSuite) TestConfiguredPrefix() {
+func (s *addressTestSuite) TestConfiguredPrefix() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
 	for length := 1; length < 10; length++ {
@@ -309,7 +309,7 @@ func (s *AddressTestSuite) TestConfiguredPrefix() {
 	}
 }
 
-func (s *AddressTestSuite) TestAddressInterface() {
+func (s *addressTestSuite) TestAddressInterface() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
 	rand.Read(pub.Key)
@@ -338,7 +338,7 @@ func (s *AddressTestSuite) TestAddressInterface() {
 
 }
 
-func (s *AddressTestSuite) TestVerifyAddressFormat() {
+func (s *addressTestSuite) TestVerifyAddressFormat() {
 	addr0 := make([]byte, 0)
 	addr5 := make([]byte, 5)
 	addr20 := make([]byte, 20)
@@ -354,7 +354,7 @@ func (s *AddressTestSuite) TestVerifyAddressFormat() {
 	s.Require().EqualError(err, "incorrect address length 32")
 }
 
-func (s *AddressTestSuite) TestCustomAddressVerifier() {
+func (s *addressTestSuite) TestCustomAddressVerifier() {
 	// Create a 10 byte address
 	addr := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	accBech := types.AccAddress(addr).String()
@@ -390,7 +390,7 @@ func (s *AddressTestSuite) TestCustomAddressVerifier() {
 	s.Require().Nil(err)
 }
 
-func (s *AddressTestSuite) TestBech32ifyAddressBytes() {
+func (s *addressTestSuite) TestBech32ifyAddressBytes() {
 	addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
 	type args struct {
@@ -423,7 +423,7 @@ func (s *AddressTestSuite) TestBech32ifyAddressBytes() {
 	}
 }
 
-func (s *AddressTestSuite) TestMustBech32ifyAddressBytes() {
+func (s *addressTestSuite) TestMustBech32ifyAddressBytes() {
 	addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
 	type args struct {
@@ -455,7 +455,7 @@ func (s *AddressTestSuite) TestMustBech32ifyAddressBytes() {
 	}
 }
 
-func (s *AddressTestSuite) TestAddressTypesEquals() {
+func (s *addressTestSuite) TestAddressTypesEquals() {
 	addr1 := secp256k1.GenPrivKey().PubKey().Address()
 	accAddr1 := types.AccAddress(addr1)
 	consAddr1 := types.ConsAddress(addr1)
@@ -495,20 +495,20 @@ func (s *AddressTestSuite) TestAddressTypesEquals() {
 	s.Require().Equal(valAddr1.Equals(valAddr2), valAddr2.Equals(valAddr1))
 }
 
-func (s *AddressTestSuite) TestNilAddressTypesEmpty() {
+func (s *addressTestSuite) TestNilAddressTypesEmpty() {
 	s.Require().True(types.AccAddress(nil).Empty())
 	s.Require().True(types.ConsAddress(nil).Empty())
 	s.Require().True(types.ValAddress(nil).Empty())
 }
 
-func (s *AddressTestSuite) TestGetConsAddress() {
+func (s *addressTestSuite) TestGetConsAddress() {
 	pk := secp256k1.GenPrivKey().PubKey()
 	s.Require().NotEqual(types.GetConsAddress(pk), pk.Address())
 	s.Require().True(bytes.Equal(types.GetConsAddress(pk).Bytes(), pk.Address().Bytes()))
 	s.Require().Panics(func() { types.GetConsAddress(crypto.PubKey(nil)) })
 }
 
-func (s *AddressTestSuite) TestGetFromBech32() {
+func (s *addressTestSuite) TestGetFromBech32() {
 	_, err := types.GetFromBech32("", "prefix")
 	s.Require().Error(err)
 	s.Require().Equal("decoding Bech32 address failed: must provide an address", err.Error())
diff --git a/types/coin_test.go b/types/coin_test.go
index 91a1fd47e7..2ef95d0f41 100644
--- a/types/coin_test.go
+++ b/types/coin_test.go
@@ -16,18 +16,18 @@ var (
 	testDenom2 = "muon"
 )
 
-type CoinTestSuite struct {
+type coinTestSuite struct {
 	suite.Suite
 }
 
 func TestCoinTestSuite(t *testing.T) {
-	suite.Run(t, new(CoinTestSuite))
+	suite.Run(t, new(coinTestSuite))
 }
 
 // ----------------------------------------------------------------------------
 // Coin tests
 
-func (s *CoinTestSuite) TestCoin() {
+func (s *coinTestSuite) TestCoin() {
 	s.Require().Panics(func() { sdk.NewInt64Coin(testDenom1, -1) })
 	s.Require().Panics(func() { sdk.NewCoin(testDenom1, sdk.NewInt(-1)) })
 	s.Require().Equal(sdk.NewInt(10), sdk.NewInt64Coin(strings.ToUpper(testDenom1), 10).Amount)
@@ -36,12 +36,12 @@ func (s *CoinTestSuite) TestCoin() {
 	s.Require().Equal(sdk.NewInt(5), sdk.NewCoin(testDenom1, sdk.NewInt(5)).Amount)
 }
 
-func (s *CoinTestSuite) TestCoin_String() {
+func (s *coinTestSuite) TestCoin_String() {
 	coin := sdk.NewCoin(testDenom1, sdk.NewInt(10))
 	s.Require().Equal(fmt.Sprintf("10%s", testDenom1), coin.String())
 }
 
-func (s *CoinTestSuite) TestIsEqualCoin() {
+func (s *coinTestSuite) TestIsEqualCoin() {
 	cases := []struct {
 		inputOne sdk.Coin
 		inputTwo sdk.Coin
@@ -64,7 +64,7 @@ func (s *CoinTestSuite) TestIsEqualCoin() {
 	}
 }
 
-func (s *CoinTestSuite) TestCoinIsValid() {
+func (s *coinTestSuite) TestCoinIsValid() {
 	loremIpsum := `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra dui vel nulla aliquet, non dictum elit aliquam. Proin consequat leo in consectetur mattis. Phasellus eget odio luctus, rutrum dolor at, venenatis ante. Praesent metus erat, sodales vitae sagittis eget, commodo non ipsum. Duis eget urna quis erat mattis pulvinar. Vivamus egestas imperdiet sem, porttitor hendrerit lorem pulvinar in. Vivamus laoreet sapien eget libero euismod tristique. Suspendisse tincidunt nulla quis luctus mattis.
 	Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed id turpis at erat placerat fermentum id sed sapien. Fusce mattis enim id nulla viverra, eget placerat eros aliquet. Nunc fringilla urna ac condimentum ultricies. Praesent in eros ac neque fringilla sodales. Donec ut venenatis eros. Quisque iaculis lectus neque, a varius sem ullamcorper nec. Cras tincidunt dignissim libero nec volutpat. Donec molestie enim sed metus venenatis, quis elementum sem varius. Curabitur eu venenatis nulla.
 	Cras sit amet ligula vel turpis placerat sollicitudin. Nunc massa odio, eleifend id lacus nec, ultricies elementum arcu. Donec imperdiet nulla lacus, a venenatis lacus fermentum nec. Proin vestibulum dolor enim, vitae posuere velit aliquet non. Suspendisse pharetra condimentum nunc tincidunt viverra. Etiam posuere, ligula ut maximus congue, mauris orci consectetur velit, vel finibus eros metus non tellus. Nullam et dictum metus. Aliquam maximus fermentum mauris elementum aliquet. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Etiam dapibus lectus sed tellus rutrum tincidunt. Nulla at dolor sem. Ut non dictum arcu, eget congue sem.`
@@ -94,7 +94,7 @@ func (s *CoinTestSuite) TestCoinIsValid() {
 	}
 }
 
-func (s *CoinTestSuite) TestAddCoin() {
+func (s *coinTestSuite) TestAddCoin() {
 	cases := []struct {
 		inputOne    sdk.Coin
 		inputTwo    sdk.Coin
@@ -117,7 +117,7 @@ func (s *CoinTestSuite) TestAddCoin() {
 	}
 }
 
-func (s *CoinTestSuite) TestSubCoin() {
+func (s *coinTestSuite) TestSubCoin() {
 	cases := []struct {
 		inputOne    sdk.Coin
 		inputTwo    sdk.Coin
@@ -150,7 +150,7 @@ func (s *CoinTestSuite) TestSubCoin() {
 	s.Require().Equal(tc.expected, res.Amount.Int64())
 }
 
-func (s *CoinTestSuite) TestIsGTECoin() {
+func (s *coinTestSuite) TestIsGTECoin() {
 	cases := []struct {
 		inputOne sdk.Coin
 		inputTwo sdk.Coin
@@ -173,7 +173,7 @@ func (s *CoinTestSuite) TestIsGTECoin() {
 	}
 }
 
-func (s *CoinTestSuite) TestIsLTCoin() {
+func (s *coinTestSuite) TestIsLTCoin() {
 	cases := []struct {
 		inputOne sdk.Coin
 		inputTwo sdk.Coin
@@ -199,7 +199,7 @@ func (s *CoinTestSuite) TestIsLTCoin() {
 	}
 }
 
-func (s *CoinTestSuite) TestCoinIsZero() {
+func (s *coinTestSuite) TestCoinIsZero() {
 	coin := sdk.NewInt64Coin(testDenom1, 0)
 	res := coin.IsZero()
 	s.Require().True(res)
@@ -209,7 +209,7 @@ func (s *CoinTestSuite) TestCoinIsZero() {
 	s.Require().False(res)
 }
 
-func (s *CoinTestSuite) TestFilteredZeroCoins() {
+func (s *coinTestSuite) TestFilteredZeroCoins() {
 	cases := []struct {
 		name     string
 		input    sdk.Coins
@@ -264,7 +264,7 @@ func (s *CoinTestSuite) TestFilteredZeroCoins() {
 // ----------------------------------------------------------------------------
 // Coins tests
 
-func (s *CoinTestSuite) TestCoins_String() {
+func (s *coinTestSuite) TestCoins_String() {
 	cases := []struct {
 		name     string
 		input    sdk.Coins
@@ -296,7 +296,7 @@ func (s *CoinTestSuite) TestCoins_String() {
 	}
 }
 
-func (s *CoinTestSuite) TestIsZeroCoins() {
+func (s *coinTestSuite) TestIsZeroCoins() {
 	cases := []struct {
 		inputOne sdk.Coins
 		expected bool
@@ -314,7 +314,7 @@ func (s *CoinTestSuite) TestIsZeroCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestEqualCoins() {
+func (s *coinTestSuite) TestEqualCoins() {
 	cases := []struct {
 		inputOne sdk.Coins
 		inputTwo sdk.Coins
@@ -341,7 +341,7 @@ func (s *CoinTestSuite) TestEqualCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestAddCoins() {
+func (s *coinTestSuite) TestAddCoins() {
 	zero := sdk.NewInt(0)
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
@@ -365,7 +365,7 @@ func (s *CoinTestSuite) TestAddCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestSubCoins() {
+func (s *coinTestSuite) TestSubCoins() {
 	zero := sdk.NewInt(0)
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
@@ -395,7 +395,7 @@ func (s *CoinTestSuite) TestSubCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestCoins_Validate() {
+func (s *coinTestSuite) TestCoins_Validate() {
 	testCases := []struct {
 		name    string
 		coins   sdk.Coins
@@ -572,7 +572,7 @@ func (s *CoinTestSuite) TestCoins_Validate() {
 	}
 }
 
-func (s *CoinTestSuite) TestCoinsGT() {
+func (s *coinTestSuite) TestCoinsGT() {
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
 
@@ -584,7 +584,7 @@ func (s *CoinTestSuite) TestCoinsGT() {
 	s.Require().False(sdk.Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(sdk.Coins{{testDenom2, two}}))
 }
 
-func (s *CoinTestSuite) TestCoinsLT() {
+func (s *coinTestSuite) TestCoinsLT() {
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
 
@@ -599,7 +599,7 @@ func (s *CoinTestSuite) TestCoinsLT() {
 	s.Require().True(sdk.Coins{}.IsAllLT(sdk.Coins{{testDenom1, one}}))
 }
 
-func (s *CoinTestSuite) TestCoinsLTE() {
+func (s *coinTestSuite) TestCoinsLTE() {
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
 
@@ -614,7 +614,7 @@ func (s *CoinTestSuite) TestCoinsLTE() {
 	s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{{testDenom1, one}}))
 }
 
-func (s *CoinTestSuite) TestParseCoins() {
+func (s *coinTestSuite) TestParseCoins() {
 	one := sdk.OneInt()
 
 	cases := []struct {
@@ -652,7 +652,7 @@ func (s *CoinTestSuite) TestParseCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestSortCoins() {
+func (s *coinTestSuite) TestSortCoins() {
 	good := sdk.Coins{
 		sdk.NewInt64Coin("gas", 1),
 		sdk.NewInt64Coin("mineral", 1),
@@ -715,7 +715,7 @@ func (s *CoinTestSuite) TestSortCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestAmountOf() {
+func (s *coinTestSuite) TestAmountOf() {
 	case0 := sdk.Coins{}
 	case1 := sdk.Coins{
 		sdk.NewInt64Coin("gold", 0),
@@ -757,7 +757,7 @@ func (s *CoinTestSuite) TestAmountOf() {
 	s.Require().Panics(func() { cases[0].coins.AmountOf("10Invalid") })
 }
 
-func (s *CoinTestSuite) TestCoinsIsAnyGTE() {
+func (s *coinTestSuite) TestCoinsIsAnyGTE() {
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
 
@@ -777,7 +777,7 @@ func (s *CoinTestSuite) TestCoinsIsAnyGTE() {
 	s.Require().True(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAnyGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
 }
 
-func (s *CoinTestSuite) TestCoinsIsAllGT() {
+func (s *coinTestSuite) TestCoinsIsAllGT() {
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
 
@@ -797,7 +797,7 @@ func (s *CoinTestSuite) TestCoinsIsAllGT() {
 	s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGT(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
 }
 
-func (s *CoinTestSuite) TestCoinsIsAllGTE() {
+func (s *coinTestSuite) TestCoinsIsAllGTE() {
 	one := sdk.OneInt()
 	two := sdk.NewInt(2)
 
@@ -819,7 +819,7 @@ func (s *CoinTestSuite) TestCoinsIsAllGTE() {
 	s.Require().False(sdk.Coins{{"xxx", one}, {"yyy", one}}.IsAllGTE(sdk.Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
 }
 
-func (s *CoinTestSuite) TestNewCoins() {
+func (s *coinTestSuite) TestNewCoins() {
 	tenatom := sdk.NewInt64Coin("atom", 10)
 	tenbtc := sdk.NewInt64Coin("btc", 10)
 	zeroeth := sdk.NewInt64Coin("eth", 0)
@@ -847,7 +847,7 @@ func (s *CoinTestSuite) TestNewCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestCoinsIsAnyGT() {
+func (s *coinTestSuite) TestCoinsIsAnyGT() {
 	twoAtom := sdk.NewInt64Coin("atom", 2)
 	fiveAtom := sdk.NewInt64Coin("atom", 5)
 	threeEth := sdk.NewInt64Coin("eth", 3)
@@ -874,7 +874,7 @@ func (s *CoinTestSuite) TestCoinsIsAnyGT() {
 	}
 }
 
-func (s *CoinTestSuite) TestMarshalJSONCoins() {
+func (s *coinTestSuite) TestMarshalJSONCoins() {
 	cdc := codec.NewLegacyAmino()
 	sdk.RegisterLegacyAminoCodec(cdc)
 
@@ -904,7 +904,7 @@ func (s *CoinTestSuite) TestMarshalJSONCoins() {
 	}
 }
 
-func (s *CoinTestSuite) TestCoinAminoEncoding() {
+func (s *coinTestSuite) TestCoinAminoEncoding() {
 	cdc := codec.NewLegacyAmino()
 	c := sdk.NewInt64Coin(testDenom1, 5)
 
diff --git a/types/config_test.go b/types/config_test.go
index df208e32f3..e2027f3856 100644
--- a/types/config_test.go
+++ b/types/config_test.go
@@ -4,47 +4,55 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestConfig_SetCoinType(t *testing.T) {
-	config := sdk.NewConfig()
-	config.SetCoinType(1)
-	require.Equal(t, uint32(1), config.GetCoinType())
-	config.SetCoinType(99)
-	require.Equal(t, uint32(99), config.GetCoinType())
-
-	config.Seal()
-	require.Panics(t, func() { config.SetCoinType(99) })
+type configTestSuite struct {
+	suite.Suite
 }
 
-func TestConfig_SetTxEncoder(t *testing.T) {
+func TestConfigTestSuite(t *testing.T) {
+	suite.Run(t, new(configTestSuite))
+}
+
+func (s *configTestSuite) TestConfig_SetCoinType() {
+	config := sdk.NewConfig()
+	config.SetCoinType(1)
+	s.Require().Equal(uint32(1), config.GetCoinType())
+	config.SetCoinType(99)
+	s.Require().Equal(uint32(99), config.GetCoinType())
+
+	config.Seal()
+	s.Require().Panics(func() { config.SetCoinType(99) })
+}
+
+func (s *configTestSuite) TestConfig_SetTxEncoder() {
 	mockErr := errors.New("test")
 	config := sdk.NewConfig()
-	require.Nil(t, config.GetTxEncoder())
+	s.Require().Nil(config.GetTxEncoder())
 	encFunc := sdk.TxEncoder(func(tx sdk.Tx) ([]byte, error) { return nil, nil })
 	config.SetTxEncoder(encFunc)
 	_, err := config.GetTxEncoder()(sdk.Tx(nil))
-	require.Error(t, mockErr, err)
+	s.Require().Error(mockErr, err)
 
 	config.Seal()
-	require.Panics(t, func() { config.SetTxEncoder(encFunc) })
+	s.Require().Panics(func() { config.SetTxEncoder(encFunc) })
 }
 
-func TestConfig_SetFullFundraiserPath(t *testing.T) {
+func (s *configTestSuite) TestConfig_SetFullFundraiserPath() {
 	config := sdk.NewConfig()
 	config.SetFullFundraiserPath("test/path")
-	require.Equal(t, "test/path", config.GetFullFundraiserPath())
+	s.Require().Equal("test/path", config.GetFullFundraiserPath())
 
 	config.SetFullFundraiserPath("test/poth")
-	require.Equal(t, "test/poth", config.GetFullFundraiserPath())
+	s.Require().Equal("test/poth", config.GetFullFundraiserPath())
 
 	config.Seal()
-	require.Panics(t, func() { config.SetFullFundraiserPath("x/test/path") })
+	s.Require().Panics(func() { config.SetFullFundraiserPath("x/test/path") })
 }
 
-func TestKeyringServiceName(t *testing.T) {
-	require.Equal(t, sdk.DefaultKeyringServiceName, sdk.KeyringServiceName())
+func (s *configTestSuite) TestKeyringServiceName() {
+	s.Require().Equal(sdk.DefaultKeyringServiceName, sdk.KeyringServiceName())
 }
diff --git a/types/context_test.go b/types/context_test.go
index 12df63bcea..018bd6a257 100644
--- a/types/context_test.go
+++ b/types/context_test.go
@@ -18,15 +18,15 @@ import (
 	"github.com/cosmos/cosmos-sdk/types"
 )
 
-type ContextTestSuite struct {
+type contextTestSuite struct {
 	suite.Suite
 }
 
 func TestContextTestSuite(t *testing.T) {
-	suite.Run(t, new(ContextTestSuite))
+	suite.Run(t, new(contextTestSuite))
 }
 
-func (s *ContextTestSuite) defaultContext(key types.StoreKey) types.Context {
+func (s *contextTestSuite) defaultContext(key types.StoreKey) types.Context {
 	db := dbm.NewMemDB()
 	cms := store.NewCommitMultiStore(db)
 	cms.MountStoreWithDB(key, types.StoreTypeIAVL, db)
@@ -35,7 +35,7 @@ func (s *ContextTestSuite) defaultContext(key types.StoreKey) types.Context {
 	return ctx
 }
 
-func (s *ContextTestSuite) TestCacheContext() {
+func (s *contextTestSuite) TestCacheContext() {
 	key := types.NewKVStoreKey(s.T().Name() + "_TestCacheContext")
 	k1 := []byte("hello")
 	v1 := []byte("world")
@@ -62,7 +62,7 @@ func (s *ContextTestSuite) TestCacheContext() {
 	s.Require().Equal(v2, store.Get(k2))
 }
 
-func (s *ContextTestSuite) TestLogContext() {
+func (s *contextTestSuite) TestLogContext() {
 	key := types.NewKVStoreKey(s.T().Name())
 	ctx := s.defaultContext(key)
 	ctrl := gomock.NewController(s.T())
@@ -86,7 +86,7 @@ func (d dummy) Clone() interface{} {
 }
 
 // Testing saving/loading sdk type values to/from the context
-func (s *ContextTestSuite) TestContextWithCustom() {
+func (s *contextTestSuite) TestContextWithCustom() {
 	var ctx types.Context
 	s.Require().True(ctx.IsZero())
 
@@ -144,7 +144,7 @@ func (s *ContextTestSuite) TestContextWithCustom() {
 }
 
 // Testing saving/loading of header fields to/from the context
-func (s *ContextTestSuite) TestContextHeader() {
+func (s *contextTestSuite) TestContextHeader() {
 	var ctx types.Context
 
 	height := int64(5)
@@ -164,7 +164,7 @@ func (s *ContextTestSuite) TestContextHeader() {
 	s.Require().Equal(proposer.Bytes(), ctx.BlockHeader().ProposerAddress)
 }
 
-func (s *ContextTestSuite) TestContextHeaderClone() {
+func (s *contextTestSuite) TestContextHeaderClone() {
 	cases := map[string]struct {
 		h tmproto.Header
 	}{
@@ -220,7 +220,7 @@ func (s *ContextTestSuite) TestContextHeaderClone() {
 	}
 }
 
-func (s *ContextTestSuite) TestUnwrapSDKContext() {
+func (s *contextTestSuite) TestUnwrapSDKContext() {
 	sdkCtx := types.NewContext(nil, tmproto.Header{}, false, nil)
 	ctx := types.WrapSDKContext(sdkCtx)
 	sdkCtx2 := types.UnwrapSDKContext(ctx)
diff --git a/types/decimal_internal_test.go b/types/decimal_internal_test.go
new file mode 100644
index 0000000000..6127267853
--- /dev/null
+++ b/types/decimal_internal_test.go
@@ -0,0 +1,82 @@
+package types
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type decimalInternalTestSuite struct {
+	suite.Suite
+}
+
+func TestDecimalInternalTestSuite(t *testing.T) {
+	suite.Run(t, new(decimalInternalTestSuite))
+}
+
+func (s *decimalInternalTestSuite) TestPrecisionMultiplier() {
+	res := precisionMultiplier(5)
+	exp := big.NewInt(10000000000000)
+	s.Require().Equal(0, res.Cmp(exp), "equality was incorrect, res %v, exp %v", res, exp)
+}
+
+func (s *decimalInternalTestSuite) TestZeroDeserializationJSON() {
+	d := Dec{new(big.Int)}
+	err := cdc.UnmarshalJSON([]byte(`"0"`), &d)
+	s.Require().Nil(err)
+	err = cdc.UnmarshalJSON([]byte(`"{}"`), &d)
+	s.Require().NotNil(err)
+}
+
+func (s *decimalInternalTestSuite) TestSerializationGocodecJSON() {
+	d := MustNewDecFromStr("0.333")
+
+	bz, err := cdc.MarshalJSON(d)
+	s.Require().NoError(err)
+
+	d2 := Dec{new(big.Int)}
+	err = cdc.UnmarshalJSON(bz, &d2)
+	s.Require().NoError(err)
+	s.Require().True(d.Equal(d2), "original: %v, unmarshalled: %v", d, d2)
+}
+
+func (s *decimalInternalTestSuite) TestDecMarshalJSON() {
+	decimal := func(i int64) Dec {
+		d := NewDec(0)
+		d.i = new(big.Int).SetInt64(i)
+		return d
+	}
+	tests := []struct {
+		name    string
+		d       Dec
+		want    string
+		wantErr bool // if wantErr = false, will also attempt unmarshaling
+	}{
+		{"zero", decimal(0), "\"0.000000000000000000\"", false},
+		{"one", decimal(1), "\"0.000000000000000001\"", false},
+		{"ten", decimal(10), "\"0.000000000000000010\"", false},
+		{"12340", decimal(12340), "\"0.000000000000012340\"", false},
+		{"zeroInt", NewDec(0), "\"0.000000000000000000\"", false},
+		{"oneInt", NewDec(1), "\"1.000000000000000000\"", false},
+		{"tenInt", NewDec(10), "\"10.000000000000000000\"", false},
+		{"12340Int", NewDec(12340), "\"12340.000000000000000000\"", false},
+	}
+	for _, tt := range tests {
+		tt := tt
+		s.T().Run(tt.name, func(t *testing.T) {
+			got, err := tt.d.MarshalJSON()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dec.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr {
+				s.Require().Equal(tt.want, string(got), "incorrect marshalled value")
+				unmarshalledDec := NewDec(0)
+				err := unmarshalledDec.UnmarshalJSON(got)
+				s.Require().NoError(err)
+				s.Require().Equal(tt.d, unmarshalledDec, "incorrect unmarshalled value")
+			}
+		})
+	}
+}
diff --git a/types/decimal_test.go b/types/decimal_test.go
index 60f29872f2..2c7e6e87ba 100644
--- a/types/decimal_test.go
+++ b/types/decimal_test.go
@@ -1,4 +1,4 @@
-package types
+package types_test
 
 import (
 	"bytes"
@@ -7,186 +7,191 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 	yaml "gopkg.in/yaml.v2"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+type decimalTestSuite struct {
+	suite.Suite
+}
+
+func TestDecimalTestSuite(t *testing.T) {
+	suite.Run(t, new(decimalTestSuite))
+}
+
 // create a decimal from a decimal string (ex. "1234.5678")
-func mustNewDecFromStr(t *testing.T, str string) (d Dec) {
-	d, err := NewDecFromStr(str)
-	require.NoError(t, err)
+func (s *decimalTestSuite) mustNewDecFromStr(str string) (d sdk.Dec) {
+	d, err := sdk.NewDecFromStr(str)
+	s.Require().NoError(err)
+
 	return d
 }
 
 //_______________________________________
 
-func TestPrecisionMultiplier(t *testing.T) {
-	res := precisionMultiplier(5)
-	exp := big.NewInt(10000000000000)
-	require.Equal(t, 0, res.Cmp(exp), "equality was incorrect, res %v, exp %v", res, exp)
-}
-
-func TestNewDecFromStr(t *testing.T) {
+func (s *decimalTestSuite) TestNewDecFromStr() {
 	largeBigInt, success := new(big.Int).SetString("3144605511029693144278234343371835", 10)
-	require.True(t, success)
+	s.Require().True(success)
+
 	tests := []struct {
 		decimalStr string
 		expErr     bool
-		exp        Dec
+		exp        sdk.Dec
 	}{
-		{"", true, Dec{}},
-		{"0.-75", true, Dec{}},
-		{"0", false, NewDec(0)},
-		{"1", false, NewDec(1)},
-		{"1.1", false, NewDecWithPrec(11, 1)},
-		{"0.75", false, NewDecWithPrec(75, 2)},
-		{"0.8", false, NewDecWithPrec(8, 1)},
-		{"0.11111", false, NewDecWithPrec(11111, 5)},
-		{"314460551102969.3144278234343371835", true, NewDec(3141203149163817869)},
+		{"", true, sdk.Dec{}},
+		{"0.-75", true, sdk.Dec{}},
+		{"0", false, sdk.NewDec(0)},
+		{"1", false, sdk.NewDec(1)},
+		{"1.1", false, sdk.NewDecWithPrec(11, 1)},
+		{"0.75", false, sdk.NewDecWithPrec(75, 2)},
+		{"0.8", false, sdk.NewDecWithPrec(8, 1)},
+		{"0.11111", false, sdk.NewDecWithPrec(11111, 5)},
+		{"314460551102969.3144278234343371835", true, sdk.NewDec(3141203149163817869)},
 		{"314460551102969314427823434337.1835718092488231350",
-			true, NewDecFromBigIntWithPrec(largeBigInt, 4)},
+			true, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4)},
 		{"314460551102969314427823434337.1835",
-			false, NewDecFromBigIntWithPrec(largeBigInt, 4)},
-		{".", true, Dec{}},
-		{".0", true, NewDec(0)},
-		{"1.", true, NewDec(1)},
-		{"foobar", true, Dec{}},
-		{"0.foobar", true, Dec{}},
-		{"0.foobar.", true, Dec{}},
+			false, sdk.NewDecFromBigIntWithPrec(largeBigInt, 4)},
+		{".", true, sdk.Dec{}},
+		{".0", true, sdk.NewDec(0)},
+		{"1.", true, sdk.NewDec(1)},
+		{"foobar", true, sdk.Dec{}},
+		{"0.foobar", true, sdk.Dec{}},
+		{"0.foobar.", true, sdk.Dec{}},
 	}
 
 	for tcIndex, tc := range tests {
-		res, err := NewDecFromStr(tc.decimalStr)
+		res, err := sdk.NewDecFromStr(tc.decimalStr)
 		if tc.expErr {
-			require.NotNil(t, err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
+			s.Require().NotNil(err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
 		} else {
-			require.Nil(t, err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
-			require.True(t, res.Equal(tc.exp), "equality was incorrect, res %v, exp %v, tc %v", res, tc.exp, tcIndex)
+			s.Require().Nil(err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
+			s.Require().True(res.Equal(tc.exp), "equality was incorrect, res %v, exp %v, tc %v", res, tc.exp, tcIndex)
 		}
 
 		// negative tc
-		res, err = NewDecFromStr("-" + tc.decimalStr)
+		res, err = sdk.NewDecFromStr("-" + tc.decimalStr)
 		if tc.expErr {
-			require.NotNil(t, err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
+			s.Require().NotNil(err, "error expected, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
 		} else {
-			require.Nil(t, err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
-			exp := tc.exp.Mul(NewDec(-1))
-			require.True(t, res.Equal(exp), "equality was incorrect, res %v, exp %v, tc %v", res, exp, tcIndex)
+			s.Require().Nil(err, "unexpected error, decimalStr %v, tc %v", tc.decimalStr, tcIndex)
+			exp := tc.exp.Mul(sdk.NewDec(-1))
+			s.Require().True(res.Equal(exp), "equality was incorrect, res %v, exp %v, tc %v", res, exp, tcIndex)
 		}
 	}
 }
 
-func TestDecString(t *testing.T) {
+func (s *decimalTestSuite) TestDecString() {
 	tests := []struct {
-		d    Dec
+		d    sdk.Dec
 		want string
 	}{
-		{NewDec(0), "0.000000000000000000"},
-		{NewDec(1), "1.000000000000000000"},
-		{NewDec(10), "10.000000000000000000"},
-		{NewDec(12340), "12340.000000000000000000"},
-		{NewDecWithPrec(12340, 4), "1.234000000000000000"},
-		{NewDecWithPrec(12340, 5), "0.123400000000000000"},
-		{NewDecWithPrec(12340, 8), "0.000123400000000000"},
-		{NewDecWithPrec(1009009009009009009, 17), "10.090090090090090090"},
+		{sdk.NewDec(0), "0.000000000000000000"},
+		{sdk.NewDec(1), "1.000000000000000000"},
+		{sdk.NewDec(10), "10.000000000000000000"},
+		{sdk.NewDec(12340), "12340.000000000000000000"},
+		{sdk.NewDecWithPrec(12340, 4), "1.234000000000000000"},
+		{sdk.NewDecWithPrec(12340, 5), "0.123400000000000000"},
+		{sdk.NewDecWithPrec(12340, 8), "0.000123400000000000"},
+		{sdk.NewDecWithPrec(1009009009009009009, 17), "10.090090090090090090"},
 	}
 	for tcIndex, tc := range tests {
-		assert.Equal(t, tc.want, tc.d.String(), "bad String(), index: %v", tcIndex)
+		s.Require().Equal(tc.want, tc.d.String(), "bad String(), index: %v", tcIndex)
 	}
 }
 
-func TestEqualities(t *testing.T) {
+func (s *decimalTestSuite) TestEqualities() {
 	tests := []struct {
-		d1, d2     Dec
+		d1, d2     sdk.Dec
 		gt, lt, eq bool
 	}{
-		{NewDec(0), NewDec(0), false, false, true},
-		{NewDecWithPrec(0, 2), NewDecWithPrec(0, 4), false, false, true},
-		{NewDecWithPrec(100, 0), NewDecWithPrec(100, 0), false, false, true},
-		{NewDecWithPrec(-100, 0), NewDecWithPrec(-100, 0), false, false, true},
-		{NewDecWithPrec(-1, 1), NewDecWithPrec(-1, 1), false, false, true},
-		{NewDecWithPrec(3333, 3), NewDecWithPrec(3333, 3), false, false, true},
+		{sdk.NewDec(0), sdk.NewDec(0), false, false, true},
+		{sdk.NewDecWithPrec(0, 2), sdk.NewDecWithPrec(0, 4), false, false, true},
+		{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(100, 0), false, false, true},
+		{sdk.NewDecWithPrec(-100, 0), sdk.NewDecWithPrec(-100, 0), false, false, true},
+		{sdk.NewDecWithPrec(-1, 1), sdk.NewDecWithPrec(-1, 1), false, false, true},
+		{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(3333, 3), false, false, true},
 
-		{NewDecWithPrec(0, 0), NewDecWithPrec(3333, 3), false, true, false},
-		{NewDecWithPrec(0, 0), NewDecWithPrec(100, 0), false, true, false},
-		{NewDecWithPrec(-1, 0), NewDecWithPrec(3333, 3), false, true, false},
-		{NewDecWithPrec(-1, 0), NewDecWithPrec(100, 0), false, true, false},
-		{NewDecWithPrec(1111, 3), NewDecWithPrec(100, 0), false, true, false},
-		{NewDecWithPrec(1111, 3), NewDecWithPrec(3333, 3), false, true, false},
-		{NewDecWithPrec(-3333, 3), NewDecWithPrec(-1111, 3), false, true, false},
+		{sdk.NewDecWithPrec(0, 0), sdk.NewDecWithPrec(3333, 3), false, true, false},
+		{sdk.NewDecWithPrec(0, 0), sdk.NewDecWithPrec(100, 0), false, true, false},
+		{sdk.NewDecWithPrec(-1, 0), sdk.NewDecWithPrec(3333, 3), false, true, false},
+		{sdk.NewDecWithPrec(-1, 0), sdk.NewDecWithPrec(100, 0), false, true, false},
+		{sdk.NewDecWithPrec(1111, 3), sdk.NewDecWithPrec(100, 0), false, true, false},
+		{sdk.NewDecWithPrec(1111, 3), sdk.NewDecWithPrec(3333, 3), false, true, false},
+		{sdk.NewDecWithPrec(-3333, 3), sdk.NewDecWithPrec(-1111, 3), false, true, false},
 
-		{NewDecWithPrec(3333, 3), NewDecWithPrec(0, 0), true, false, false},
-		{NewDecWithPrec(100, 0), NewDecWithPrec(0, 0), true, false, false},
-		{NewDecWithPrec(3333, 3), NewDecWithPrec(-1, 0), true, false, false},
-		{NewDecWithPrec(100, 0), NewDecWithPrec(-1, 0), true, false, false},
-		{NewDecWithPrec(100, 0), NewDecWithPrec(1111, 3), true, false, false},
-		{NewDecWithPrec(3333, 3), NewDecWithPrec(1111, 3), true, false, false},
-		{NewDecWithPrec(-1111, 3), NewDecWithPrec(-3333, 3), true, false, false},
+		{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(0, 0), true, false, false},
+		{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(0, 0), true, false, false},
+		{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(-1, 0), true, false, false},
+		{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(-1, 0), true, false, false},
+		{sdk.NewDecWithPrec(100, 0), sdk.NewDecWithPrec(1111, 3), true, false, false},
+		{sdk.NewDecWithPrec(3333, 3), sdk.NewDecWithPrec(1111, 3), true, false, false},
+		{sdk.NewDecWithPrec(-1111, 3), sdk.NewDecWithPrec(-3333, 3), true, false, false},
 	}
 
 	for tcIndex, tc := range tests {
-		require.Equal(t, tc.gt, tc.d1.GT(tc.d2), "GT result is incorrect, tc %d", tcIndex)
-		require.Equal(t, tc.lt, tc.d1.LT(tc.d2), "LT result is incorrect, tc %d", tcIndex)
-		require.Equal(t, tc.eq, tc.d1.Equal(tc.d2), "equality result is incorrect, tc %d", tcIndex)
+		s.Require().Equal(tc.gt, tc.d1.GT(tc.d2), "GT result is incorrect, tc %d", tcIndex)
+		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 TestDecsEqual(t *testing.T) {
+func (s *decimalTestSuite) TestDecsEqual() {
 	tests := []struct {
-		d1s, d2s []Dec
+		d1s, d2s []sdk.Dec
 		eq       bool
 	}{
-		{[]Dec{NewDec(0)}, []Dec{NewDec(0)}, true},
-		{[]Dec{NewDec(0)}, []Dec{NewDec(1)}, false},
-		{[]Dec{NewDec(0)}, []Dec{}, false},
-		{[]Dec{NewDec(0), NewDec(1)}, []Dec{NewDec(0), NewDec(1)}, true},
-		{[]Dec{NewDec(1), NewDec(0)}, []Dec{NewDec(1), NewDec(0)}, true},
-		{[]Dec{NewDec(1), NewDec(0)}, []Dec{NewDec(0), NewDec(1)}, false},
-		{[]Dec{NewDec(1), NewDec(0)}, []Dec{NewDec(1)}, false},
-		{[]Dec{NewDec(1), NewDec(2)}, []Dec{NewDec(2), NewDec(4)}, false},
-		{[]Dec{NewDec(3), NewDec(18)}, []Dec{NewDec(1), NewDec(6)}, false},
+		{[]sdk.Dec{sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(0)}, true},
+		{[]sdk.Dec{sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(1)}, false},
+		{[]sdk.Dec{sdk.NewDec(0)}, []sdk.Dec{}, false},
+		{[]sdk.Dec{sdk.NewDec(0), sdk.NewDec(1)}, []sdk.Dec{sdk.NewDec(0), sdk.NewDec(1)}, true},
+		{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, true},
+		{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(0), sdk.NewDec(1)}, false},
+		{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(0)}, []sdk.Dec{sdk.NewDec(1)}, false},
+		{[]sdk.Dec{sdk.NewDec(1), sdk.NewDec(2)}, []sdk.Dec{sdk.NewDec(2), sdk.NewDec(4)}, false},
+		{[]sdk.Dec{sdk.NewDec(3), sdk.NewDec(18)}, []sdk.Dec{sdk.NewDec(1), sdk.NewDec(6)}, false},
 	}
 
 	for tcIndex, tc := range tests {
-		require.Equal(t, tc.eq, DecsEqual(tc.d1s, tc.d2s), "equality of decional arrays is incorrect, tc %d", tcIndex)
-		require.Equal(t, tc.eq, DecsEqual(tc.d2s, tc.d1s), "equality of decional arrays is incorrect (converse), tc %d", tcIndex)
+		s.Require().Equal(tc.eq, sdk.DecsEqual(tc.d1s, tc.d2s), "equality of decional arrays is incorrect, tc %d", tcIndex)
+		s.Require().Equal(tc.eq, sdk.DecsEqual(tc.d2s, tc.d1s), "equality of decional arrays is incorrect (converse), tc %d", tcIndex)
 	}
 }
 
-func TestArithmetic(t *testing.T) {
+func (s *decimalTestSuite) TestArithmetic() {
 	tests := []struct {
-		d1, d2                                Dec
-		expMul, expMulTruncate                Dec
-		expQuo, expQuoRoundUp, expQuoTruncate Dec
-		expAdd, expSub                        Dec
+		d1, d2                                sdk.Dec
+		expMul, expMulTruncate                sdk.Dec
+		expQuo, expQuoRoundUp, expQuoTruncate sdk.Dec
+		expAdd, expSub                        sdk.Dec
 	}{
 		//  d1         d2         MUL    MulTruncate    QUO    QUORoundUp QUOTrunctate  ADD         SUB
-		{NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0)},
-		{NewDec(1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(1), NewDec(1)},
-		{NewDec(0), NewDec(1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(1), NewDec(-1)},
-		{NewDec(0), NewDec(-1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(-1), NewDec(1)},
-		{NewDec(-1), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(0), NewDec(-1), NewDec(-1)},
+		{sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0)},
+		{sdk.NewDec(1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(1), sdk.NewDec(1)},
+		{sdk.NewDec(0), sdk.NewDec(1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(1), sdk.NewDec(-1)},
+		{sdk.NewDec(0), sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(-1), sdk.NewDec(1)},
+		{sdk.NewDec(-1), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(0), sdk.NewDec(-1), sdk.NewDec(-1)},
 
-		{NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(2), NewDec(0)},
-		{NewDec(-1), NewDec(-1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(1), NewDec(-2), NewDec(0)},
-		{NewDec(1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(0), NewDec(2)},
-		{NewDec(-1), NewDec(1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(-1), NewDec(0), 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(2), sdk.NewDec(0)},
+		{sdk.NewDec(-1), sdk.NewDec(-1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(-2), sdk.NewDec(0)},
+		{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)},
 
-		{NewDec(3), NewDec(7), NewDec(21), NewDec(21),
-			NewDecWithPrec(428571428571428571, 18), NewDecWithPrec(428571428571428572, 18), NewDecWithPrec(428571428571428571, 18),
-			NewDec(10), NewDec(-4)},
-		{NewDec(2), NewDec(4), NewDec(8), NewDec(8), NewDecWithPrec(5, 1), NewDecWithPrec(5, 1), NewDecWithPrec(5, 1),
-			NewDec(6), NewDec(-2)},
+		{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)},
 
-		{NewDec(100), NewDec(100), NewDec(10000), NewDec(10000), NewDec(1), NewDec(1), NewDec(1), NewDec(200), NewDec(0)},
+		{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)},
 
-		{NewDecWithPrec(15, 1), NewDecWithPrec(15, 1), NewDecWithPrec(225, 2), NewDecWithPrec(225, 2),
-			NewDec(1), NewDec(1), NewDec(1), NewDec(3), NewDec(0)},
-		{NewDecWithPrec(3333, 4), NewDecWithPrec(333, 4), NewDecWithPrec(1109889, 8), NewDecWithPrec(1109889, 8),
-			MustNewDecFromStr("10.009009009009009009"), MustNewDecFromStr("10.009009009009009010"), MustNewDecFromStr("10.009009009009009009"),
-			NewDecWithPrec(3666, 4), NewDecWithPrec(3, 1)},
+		{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)},
 	}
 
 	for tcIndex, tc := range tests {
@@ -195,227 +200,167 @@ func TestArithmetic(t *testing.T) {
 		resSub := tc.d1.Sub(tc.d2)
 		resMul := tc.d1.Mul(tc.d2)
 		resMulTruncate := tc.d1.MulTruncate(tc.d2)
-		require.True(t, tc.expAdd.Equal(resAdd), "exp %v, res %v, tc %d", tc.expAdd, resAdd, tcIndex)
-		require.True(t, tc.expSub.Equal(resSub), "exp %v, res %v, tc %d", tc.expSub, resSub, tcIndex)
-		require.True(t, tc.expMul.Equal(resMul), "exp %v, res %v, tc %d", tc.expMul, resMul, tcIndex)
-		require.True(t, tc.expMulTruncate.Equal(resMulTruncate), "exp %v, res %v, tc %d", tc.expMulTruncate, resMulTruncate, tcIndex)
+		s.Require().True(tc.expAdd.Equal(resAdd), "exp %v, res %v, tc %d", tc.expAdd, resAdd, tcIndex)
+		s.Require().True(tc.expSub.Equal(resSub), "exp %v, res %v, tc %d", tc.expSub, resSub, tcIndex)
+		s.Require().True(tc.expMul.Equal(resMul), "exp %v, res %v, tc %d", tc.expMul, resMul, tcIndex)
+		s.Require().True(tc.expMulTruncate.Equal(resMulTruncate), "exp %v, res %v, tc %d", tc.expMulTruncate, resMulTruncate, tcIndex)
 
 		if tc.d2.IsZero() { // panic for divide by zero
-			require.Panics(t, func() { tc.d1.Quo(tc.d2) })
+			s.Require().Panics(func() { tc.d1.Quo(tc.d2) })
 		} else {
 			resQuo := tc.d1.Quo(tc.d2)
-			require.True(t, tc.expQuo.Equal(resQuo), "exp %v, res %v, tc %d", tc.expQuo.String(), resQuo.String(), tcIndex)
+			s.Require().True(tc.expQuo.Equal(resQuo), "exp %v, res %v, tc %d", tc.expQuo.String(), resQuo.String(), tcIndex)
 
 			resQuoRoundUp := tc.d1.QuoRoundUp(tc.d2)
-			require.True(t, tc.expQuoRoundUp.Equal(resQuoRoundUp), "exp %v, res %v, tc %d",
+			s.Require().True(tc.expQuoRoundUp.Equal(resQuoRoundUp), "exp %v, res %v, tc %d",
 				tc.expQuoRoundUp.String(), resQuoRoundUp.String(), tcIndex)
 
 			resQuoTruncate := tc.d1.QuoTruncate(tc.d2)
-			require.True(t, tc.expQuoTruncate.Equal(resQuoTruncate), "exp %v, res %v, tc %d",
+			s.Require().True(tc.expQuoTruncate.Equal(resQuoTruncate), "exp %v, res %v, tc %d",
 				tc.expQuoTruncate.String(), resQuoTruncate.String(), tcIndex)
 		}
 	}
 }
 
-func TestBankerRoundChop(t *testing.T) {
+func (s *decimalTestSuite) TestBankerRoundChop() {
 	tests := []struct {
-		d1  Dec
+		d1  sdk.Dec
 		exp int64
 	}{
-		{mustNewDecFromStr(t, "0.25"), 0},
-		{mustNewDecFromStr(t, "0"), 0},
-		{mustNewDecFromStr(t, "1"), 1},
-		{mustNewDecFromStr(t, "0.75"), 1},
-		{mustNewDecFromStr(t, "0.5"), 0},
-		{mustNewDecFromStr(t, "7.5"), 8},
-		{mustNewDecFromStr(t, "1.5"), 2},
-		{mustNewDecFromStr(t, "2.5"), 2},
-		{mustNewDecFromStr(t, "0.545"), 1}, // 0.545-> 1 even though 5 is first decimal and 1 not even
-		{mustNewDecFromStr(t, "1.545"), 2},
+		{s.mustNewDecFromStr("0.25"), 0},
+		{s.mustNewDecFromStr("0"), 0},
+		{s.mustNewDecFromStr("1"), 1},
+		{s.mustNewDecFromStr("0.75"), 1},
+		{s.mustNewDecFromStr("0.5"), 0},
+		{s.mustNewDecFromStr("7.5"), 8},
+		{s.mustNewDecFromStr("1.5"), 2},
+		{s.mustNewDecFromStr("2.5"), 2},
+		{s.mustNewDecFromStr("0.545"), 1}, // 0.545-> 1 even though 5 is first decimal and 1 not even
+		{s.mustNewDecFromStr("1.545"), 2},
 	}
 
 	for tcIndex, tc := range tests {
 		resNeg := tc.d1.Neg().RoundInt64()
-		require.Equal(t, -1*tc.exp, resNeg, "negative tc %d", tcIndex)
+		s.Require().Equal(-1*tc.exp, resNeg, "negative tc %d", tcIndex)
 
 		resPos := tc.d1.RoundInt64()
-		require.Equal(t, tc.exp, resPos, "positive tc %d", tcIndex)
+		s.Require().Equal(tc.exp, resPos, "positive tc %d", tcIndex)
 	}
 }
 
-func TestTruncate(t *testing.T) {
+func (s *decimalTestSuite) TestTruncate() {
 	tests := []struct {
-		d1  Dec
+		d1  sdk.Dec
 		exp int64
 	}{
-		{mustNewDecFromStr(t, "0"), 0},
-		{mustNewDecFromStr(t, "0.25"), 0},
-		{mustNewDecFromStr(t, "0.75"), 0},
-		{mustNewDecFromStr(t, "1"), 1},
-		{mustNewDecFromStr(t, "1.5"), 1},
-		{mustNewDecFromStr(t, "7.5"), 7},
-		{mustNewDecFromStr(t, "7.6"), 7},
-		{mustNewDecFromStr(t, "7.4"), 7},
-		{mustNewDecFromStr(t, "100.1"), 100},
-		{mustNewDecFromStr(t, "1000.1"), 1000},
+		{s.mustNewDecFromStr("0"), 0},
+		{s.mustNewDecFromStr("0.25"), 0},
+		{s.mustNewDecFromStr("0.75"), 0},
+		{s.mustNewDecFromStr("1"), 1},
+		{s.mustNewDecFromStr("1.5"), 1},
+		{s.mustNewDecFromStr("7.5"), 7},
+		{s.mustNewDecFromStr("7.6"), 7},
+		{s.mustNewDecFromStr("7.4"), 7},
+		{s.mustNewDecFromStr("100.1"), 100},
+		{s.mustNewDecFromStr("1000.1"), 1000},
 	}
 
 	for tcIndex, tc := range tests {
 		resNeg := tc.d1.Neg().TruncateInt64()
-		require.Equal(t, -1*tc.exp, resNeg, "negative tc %d", tcIndex)
+		s.Require().Equal(-1*tc.exp, resNeg, "negative tc %d", tcIndex)
 
 		resPos := tc.d1.TruncateInt64()
-		require.Equal(t, tc.exp, resPos, "positive tc %d", tcIndex)
+		s.Require().Equal(tc.exp, resPos, "positive tc %d", tcIndex)
 	}
 }
 
-func TestDecMarshalJSON(t *testing.T) {
-	decimal := func(i int64) Dec {
-		d := NewDec(0)
-		d.i = new(big.Int).SetInt64(i)
-		return d
-	}
-	tests := []struct {
-		name    string
-		d       Dec
-		want    string
-		wantErr bool // if wantErr = false, will also attempt unmarshaling
-	}{
-		{"zero", decimal(0), "\"0.000000000000000000\"", false},
-		{"one", decimal(1), "\"0.000000000000000001\"", false},
-		{"ten", decimal(10), "\"0.000000000000000010\"", false},
-		{"12340", decimal(12340), "\"0.000000000000012340\"", false},
-		{"zeroInt", NewDec(0), "\"0.000000000000000000\"", false},
-		{"oneInt", NewDec(1), "\"1.000000000000000000\"", false},
-		{"tenInt", NewDec(10), "\"10.000000000000000000\"", false},
-		{"12340Int", NewDec(12340), "\"12340.000000000000000000\"", false},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.d.MarshalJSON()
-			if (err != nil) != tt.wantErr {
-				t.Errorf("Dec.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr {
-				assert.Equal(t, tt.want, string(got), "incorrect marshalled value")
-				unmarshalledDec := NewDec(0)
-				err := unmarshalledDec.UnmarshalJSON(got)
-				assert.NoError(t, err)
-				assert.Equal(t, tt.d, unmarshalledDec, "incorrect unmarshalled value")
-			}
-		})
-	}
-}
-
-func TestZeroDeserializationJSON(t *testing.T) {
-	d := Dec{new(big.Int)}
-	err := cdc.UnmarshalJSON([]byte(`"0"`), &d)
-	require.Nil(t, err)
-	err = cdc.UnmarshalJSON([]byte(`"{}"`), &d)
-	require.NotNil(t, err)
-}
-
-func TestSerializationGocodecJSON(t *testing.T) {
-	d := mustNewDecFromStr(t, "0.333")
-
-	bz, err := cdc.MarshalJSON(d)
-	require.NoError(t, err)
-
-	d2 := Dec{new(big.Int)}
-	err = cdc.UnmarshalJSON(bz, &d2)
-	require.NoError(t, err)
-	require.True(t, d.Equal(d2), "original: %v, unmarshalled: %v", d, d2)
-}
-
-func TestStringOverflow(t *testing.T) {
+func (s *decimalTestSuite) TestStringOverflow() {
 	// two random 64 bit primes
-	dec1, err := NewDecFromStr("51643150036226787134389711697696177267")
-	require.NoError(t, err)
-	dec2, err := NewDecFromStr("-31798496660535729618459429845579852627")
-	require.NoError(t, err)
+	dec1, err := sdk.NewDecFromStr("51643150036226787134389711697696177267")
+	s.Require().NoError(err)
+	dec2, err := sdk.NewDecFromStr("-31798496660535729618459429845579852627")
+	s.Require().NoError(err)
 	dec3 := dec1.Add(dec2)
-	require.Equal(t,
+	s.Require().Equal(
 		"19844653375691057515930281852116324640.000000000000000000",
 		dec3.String(),
 	)
 }
 
-func TestDecMulInt(t *testing.T) {
+func (s *decimalTestSuite) TestDecMulInt() {
 	tests := []struct {
-		sdkDec Dec
-		sdkInt Int
-		want   Dec
+		sdkDec sdk.Dec
+		sdkInt sdk.Int
+		want   sdk.Dec
 	}{
-		{NewDec(10), NewInt(2), NewDec(20)},
-		{NewDec(1000000), NewInt(100), NewDec(100000000)},
-		{NewDecWithPrec(1, 1), NewInt(10), NewDec(1)},
-		{NewDecWithPrec(1, 5), NewInt(20), NewDecWithPrec(2, 4)},
+		{sdk.NewDec(10), sdk.NewInt(2), sdk.NewDec(20)},
+		{sdk.NewDec(1000000), sdk.NewInt(100), sdk.NewDec(100000000)},
+		{sdk.NewDecWithPrec(1, 1), sdk.NewInt(10), sdk.NewDec(1)},
+		{sdk.NewDecWithPrec(1, 5), sdk.NewInt(20), sdk.NewDecWithPrec(2, 4)},
 	}
 	for i, tc := range tests {
 		got := tc.sdkDec.MulInt(tc.sdkInt)
-		require.Equal(t, tc.want, got, "Incorrect result on test case %d", i)
+		s.Require().Equal(tc.want, got, "Incorrect result on test case %d", i)
 	}
 }
 
-func TestDecCeil(t *testing.T) {
+func (s *decimalTestSuite) TestDecCeil() {
 	testCases := []struct {
-		input    Dec
-		expected Dec
+		input    sdk.Dec
+		expected sdk.Dec
 	}{
-		{NewDecWithPrec(1000000000000000, Precision), NewDec(1)},  // 0.001 => 1.0
-		{NewDecWithPrec(-1000000000000000, Precision), ZeroDec()}, // -0.001 => 0.0
-		{ZeroDec(), ZeroDec()}, // 0.0 => 0.0
-		{NewDecWithPrec(900000000000000000, Precision), NewDec(1)},    // 0.9 => 1.0
-		{NewDecWithPrec(4001000000000000000, Precision), NewDec(5)},   // 4.001 => 5.0
-		{NewDecWithPrec(-4001000000000000000, Precision), NewDec(-4)}, // -4.001 => -4.0
-		{NewDecWithPrec(4700000000000000000, Precision), NewDec(5)},   // 4.7 => 5.0
-		{NewDecWithPrec(-4700000000000000000, Precision), NewDec(-4)}, // -4.7 => -4.0
+		{sdk.NewDecWithPrec(1000000000000000, sdk.Precision), sdk.NewDec(1)},      // 0.001 => 1.0
+		{sdk.NewDecWithPrec(-1000000000000000, sdk.Precision), sdk.ZeroDec()},     // -0.001 => 0.0
+		{sdk.ZeroDec(), sdk.ZeroDec()},                                            // 0.0 => 0.0
+		{sdk.NewDecWithPrec(900000000000000000, sdk.Precision), sdk.NewDec(1)},    // 0.9 => 1.0
+		{sdk.NewDecWithPrec(4001000000000000000, sdk.Precision), sdk.NewDec(5)},   // 4.001 => 5.0
+		{sdk.NewDecWithPrec(-4001000000000000000, sdk.Precision), sdk.NewDec(-4)}, // -4.001 => -4.0
+		{sdk.NewDecWithPrec(4700000000000000000, sdk.Precision), sdk.NewDec(5)},   // 4.7 => 5.0
+		{sdk.NewDecWithPrec(-4700000000000000000, sdk.Precision), sdk.NewDec(-4)}, // -4.7 => -4.0
 	}
 
 	for i, tc := range testCases {
 		res := tc.input.Ceil()
-		require.Equal(t, tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
+		s.Require().Equal(tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
 	}
 }
 
-func TestPower(t *testing.T) {
+func (s *decimalTestSuite) TestPower() {
 	testCases := []struct {
-		input    Dec
+		input    sdk.Dec
 		power    uint64
-		expected Dec
+		expected sdk.Dec
 	}{
-		{OneDec(), 10, OneDec()},                                               // 1.0 ^ (10) => 1.0
-		{NewDecWithPrec(5, 1), 2, NewDecWithPrec(25, 2)},                       // 0.5 ^ 2 => 0.25
-		{NewDecWithPrec(2, 1), 2, NewDecWithPrec(4, 2)},                        // 0.2 ^ 2 => 0.04
-		{NewDecFromInt(NewInt(3)), 3, NewDecFromInt(NewInt(27))},               // 3 ^ 3 => 27
-		{NewDecFromInt(NewInt(-3)), 4, NewDecFromInt(NewInt(81))},              // -3 ^ 4 = 81
-		{NewDecWithPrec(1414213562373095049, 18), 2, NewDecFromInt(NewInt(2))}, // 1.414213562373095049 ^ 2 = 2
+		{sdk.OneDec(), 10, sdk.OneDec()},                                                   // 1.0 ^ (10) => 1.0
+		{sdk.NewDecWithPrec(5, 1), 2, sdk.NewDecWithPrec(25, 2)},                           // 0.5 ^ 2 => 0.25
+		{sdk.NewDecWithPrec(2, 1), 2, sdk.NewDecWithPrec(4, 2)},                            // 0.2 ^ 2 => 0.04
+		{sdk.NewDecFromInt(sdk.NewInt(3)), 3, sdk.NewDecFromInt(sdk.NewInt(27))},           // 3 ^ 3 => 27
+		{sdk.NewDecFromInt(sdk.NewInt(-3)), 4, sdk.NewDecFromInt(sdk.NewInt(81))},          // -3 ^ 4 = 81
+		{sdk.NewDecWithPrec(1414213562373095049, 18), 2, sdk.NewDecFromInt(sdk.NewInt(2))}, // 1.414213562373095049 ^ 2 = 2
 	}
 
 	for i, tc := range testCases {
 		res := tc.input.Power(tc.power)
-		require.True(t, tc.expected.Sub(res).Abs().LTE(SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
+		s.Require().True(tc.expected.Sub(res).Abs().LTE(sdk.SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
 	}
 }
 
-func TestApproxRoot(t *testing.T) {
+func (s *decimalTestSuite) TestApproxRoot() {
 	testCases := []struct {
-		input    Dec
+		input    sdk.Dec
 		root     uint64
-		expected Dec
+		expected sdk.Dec
 	}{
-		{OneDec(), 10, OneDec()},                                                       // 1.0 ^ (0.1) => 1.0
-		{NewDecWithPrec(25, 2), 2, NewDecWithPrec(5, 1)},                               // 0.25 ^ (0.5) => 0.5
-		{NewDecWithPrec(4, 2), 2, NewDecWithPrec(2, 1)},                                // 0.04 ^ (0.5) => 0.2
-		{NewDecFromInt(NewInt(27)), 3, NewDecFromInt(NewInt(3))},                       // 27 ^ (1/3) => 3
-		{NewDecFromInt(NewInt(-81)), 4, NewDecFromInt(NewInt(-3))},                     // -81 ^ (0.25) => -3
-		{NewDecFromInt(NewInt(2)), 2, NewDecWithPrec(1414213562373095049, 18)},         // 2 ^ (0.5) => 1.414213562373095049
-		{NewDecWithPrec(1005, 3), 31536000, MustNewDecFromStr("1.000000000158153904")}, // 1.005 ^ (1/31536000) ≈ 1.00000000016
-		{SmallestDec(), 2, NewDecWithPrec(1, 9)},                                       // 1e-18 ^ (0.5) => 1e-9
-		{SmallestDec(), 3, MustNewDecFromStr("0.000000999999999997")},                  // 1e-18 ^ (1/3) => 1e-6
-		{NewDecWithPrec(1, 8), 3, MustNewDecFromStr("0.002154434690031900")},           // 1e-8 ^ (1/3) ≈ 0.00215443469
+		{sdk.OneDec(), 10, sdk.OneDec()},                                                       // 1.0 ^ (0.1) => 1.0
+		{sdk.NewDecWithPrec(25, 2), 2, sdk.NewDecWithPrec(5, 1)},                               // 0.25 ^ (0.5) => 0.5
+		{sdk.NewDecWithPrec(4, 2), 2, sdk.NewDecWithPrec(2, 1)},                                // 0.04 ^ (0.5) => 0.2
+		{sdk.NewDecFromInt(sdk.NewInt(27)), 3, sdk.NewDecFromInt(sdk.NewInt(3))},               // 27 ^ (1/3) => 3
+		{sdk.NewDecFromInt(sdk.NewInt(-81)), 4, sdk.NewDecFromInt(sdk.NewInt(-3))},             // -81 ^ (0.25) => -3
+		{sdk.NewDecFromInt(sdk.NewInt(2)), 2, sdk.NewDecWithPrec(1414213562373095049, 18)},     // 2 ^ (0.5) => 1.414213562373095049
+		{sdk.NewDecWithPrec(1005, 3), 31536000, sdk.MustNewDecFromStr("1.000000000158153904")}, // 1.005 ^ (1/31536000) ≈ 1.00000000016
+		{sdk.SmallestDec(), 2, sdk.NewDecWithPrec(1, 9)},                                       // 1e-18 ^ (0.5) => 1e-9
+		{sdk.SmallestDec(), 3, sdk.MustNewDecFromStr("0.000000999999999997")},                  // 1e-18 ^ (1/3) => 1e-6
+		{sdk.NewDecWithPrec(1, 8), 3, sdk.MustNewDecFromStr("0.002154434690031900")},           // 1e-8 ^ (1/3) ≈ 0.00215443469
 	}
 
 	// In the case of 1e-8 ^ (1/3), the result repeats every 5 iterations starting from iteration 24
@@ -424,88 +369,88 @@ func TestApproxRoot(t *testing.T) {
 
 	for i, tc := range testCases {
 		res, err := tc.input.ApproxRoot(tc.root)
-		require.NoError(t, err)
-		require.True(t, tc.expected.Sub(res).Abs().LTE(SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
+		s.Require().NoError(err)
+		s.Require().True(tc.expected.Sub(res).Abs().LTE(sdk.SmallestDec()), "unexpected result for test case %d, input: %v", i, tc.input)
 	}
 }
 
-func TestApproxSqrt(t *testing.T) {
+func (s *decimalTestSuite) TestApproxSqrt() {
 	testCases := []struct {
-		input    Dec
-		expected Dec
+		input    sdk.Dec
+		expected sdk.Dec
 	}{
-		{OneDec(), OneDec()},                                                // 1.0 => 1.0
-		{NewDecWithPrec(25, 2), NewDecWithPrec(5, 1)},                       // 0.25 => 0.5
-		{NewDecWithPrec(4, 2), NewDecWithPrec(2, 1)},                        // 0.09 => 0.3
-		{NewDecFromInt(NewInt(9)), NewDecFromInt(NewInt(3))},                // 9 => 3
-		{NewDecFromInt(NewInt(-9)), NewDecFromInt(NewInt(-3))},              // -9 => -3
-		{NewDecFromInt(NewInt(2)), NewDecWithPrec(1414213562373095049, 18)}, // 2 => 1.414213562373095049
+		{sdk.OneDec(), sdk.OneDec()},                                                    // 1.0 => 1.0
+		{sdk.NewDecWithPrec(25, 2), sdk.NewDecWithPrec(5, 1)},                           // 0.25 => 0.5
+		{sdk.NewDecWithPrec(4, 2), sdk.NewDecWithPrec(2, 1)},                            // 0.09 => 0.3
+		{sdk.NewDecFromInt(sdk.NewInt(9)), sdk.NewDecFromInt(sdk.NewInt(3))},            // 9 => 3
+		{sdk.NewDecFromInt(sdk.NewInt(-9)), sdk.NewDecFromInt(sdk.NewInt(-3))},          // -9 => -3
+		{sdk.NewDecFromInt(sdk.NewInt(2)), sdk.NewDecWithPrec(1414213562373095049, 18)}, // 2 => 1.414213562373095049
 	}
 
 	for i, tc := range testCases {
 		res, err := tc.input.ApproxSqrt()
-		require.NoError(t, err)
-		require.Equal(t, tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
+		s.Require().NoError(err)
+		s.Require().Equal(tc.expected, res, "unexpected result for test case %d, input: %v", i, tc.input)
 	}
 }
 
-func TestDecSortableBytes(t *testing.T) {
+func (s *decimalTestSuite) TestDecSortableBytes() {
 	tests := []struct {
-		d    Dec
+		d    sdk.Dec
 		want []byte
 	}{
-		{NewDec(0), []byte("000000000000000000.000000000000000000")},
-		{NewDec(1), []byte("000000000000000001.000000000000000000")},
-		{NewDec(10), []byte("000000000000000010.000000000000000000")},
-		{NewDec(12340), []byte("000000000000012340.000000000000000000")},
-		{NewDecWithPrec(12340, 4), []byte("000000000000000001.234000000000000000")},
-		{NewDecWithPrec(12340, 5), []byte("000000000000000000.123400000000000000")},
-		{NewDecWithPrec(12340, 8), []byte("000000000000000000.000123400000000000")},
-		{NewDecWithPrec(1009009009009009009, 17), []byte("000000000000000010.090090090090090090")},
-		{NewDecWithPrec(-1009009009009009009, 17), []byte("-000000000000000010.090090090090090090")},
-		{NewDec(1000000000000000000), []byte("max")},
-		{NewDec(-1000000000000000000), []byte("--")},
+		{sdk.NewDec(0), []byte("000000000000000000.000000000000000000")},
+		{sdk.NewDec(1), []byte("000000000000000001.000000000000000000")},
+		{sdk.NewDec(10), []byte("000000000000000010.000000000000000000")},
+		{sdk.NewDec(12340), []byte("000000000000012340.000000000000000000")},
+		{sdk.NewDecWithPrec(12340, 4), []byte("000000000000000001.234000000000000000")},
+		{sdk.NewDecWithPrec(12340, 5), []byte("000000000000000000.123400000000000000")},
+		{sdk.NewDecWithPrec(12340, 8), []byte("000000000000000000.000123400000000000")},
+		{sdk.NewDecWithPrec(1009009009009009009, 17), []byte("000000000000000010.090090090090090090")},
+		{sdk.NewDecWithPrec(-1009009009009009009, 17), []byte("-000000000000000010.090090090090090090")},
+		{sdk.NewDec(1000000000000000000), []byte("max")},
+		{sdk.NewDec(-1000000000000000000), []byte("--")},
 	}
 	for tcIndex, tc := range tests {
-		assert.Equal(t, tc.want, SortableDecBytes(tc.d), "bad String(), index: %v", tcIndex)
+		s.Require().Equal(tc.want, sdk.SortableDecBytes(tc.d), "bad String(), index: %v", tcIndex)
 	}
 
-	assert.Panics(t, func() { SortableDecBytes(NewDec(1000000000000000001)) })
-	assert.Panics(t, func() { SortableDecBytes(NewDec(-1000000000000000001)) })
+	s.Require().Panics(func() { sdk.SortableDecBytes(sdk.NewDec(1000000000000000001)) })
+	s.Require().Panics(func() { sdk.SortableDecBytes(sdk.NewDec(-1000000000000000001)) })
 }
 
-func TestDecEncoding(t *testing.T) {
+func (s *decimalTestSuite) TestDecEncoding() {
 	testCases := []struct {
-		input   Dec
+		input   sdk.Dec
 		rawBz   string
 		jsonStr string
 		yamlStr string
 	}{
 		{
-			NewDec(0), "30",
+			sdk.NewDec(0), "30",
 			"\"0.000000000000000000\"",
 			"\"0.000000000000000000\"\n",
 		},
 		{
-			NewDecWithPrec(4, 2),
+			sdk.NewDecWithPrec(4, 2),
 			"3430303030303030303030303030303030",
 			"\"0.040000000000000000\"",
 			"\"0.040000000000000000\"\n",
 		},
 		{
-			NewDecWithPrec(-4, 2),
+			sdk.NewDecWithPrec(-4, 2),
 			"2D3430303030303030303030303030303030",
 			"\"-0.040000000000000000\"",
 			"\"-0.040000000000000000\"\n",
 		},
 		{
-			NewDecWithPrec(1414213562373095049, 18),
+			sdk.NewDecWithPrec(1414213562373095049, 18),
 			"31343134323133353632333733303935303439",
 			"\"1.414213562373095049\"",
 			"\"1.414213562373095049\"\n",
 		},
 		{
-			NewDecWithPrec(-1414213562373095049, 18),
+			sdk.NewDecWithPrec(-1414213562373095049, 18),
 			"2D31343134323133353632333733303935303439",
 			"\"-1.414213562373095049\"",
 			"\"-1.414213562373095049\"\n",
@@ -514,38 +459,38 @@ func TestDecEncoding(t *testing.T) {
 
 	for _, tc := range testCases {
 		bz, err := tc.input.Marshal()
-		require.NoError(t, err)
-		require.Equal(t, tc.rawBz, fmt.Sprintf("%X", bz))
+		s.Require().NoError(err)
+		s.Require().Equal(tc.rawBz, fmt.Sprintf("%X", bz))
 
-		var other Dec
-		require.NoError(t, (&other).Unmarshal(bz))
-		require.True(t, tc.input.Equal(other))
+		var other sdk.Dec
+		s.Require().NoError((&other).Unmarshal(bz))
+		s.Require().True(tc.input.Equal(other))
 
 		bz, err = json.Marshal(tc.input)
-		require.NoError(t, err)
-		require.Equal(t, tc.jsonStr, string(bz))
-		require.NoError(t, json.Unmarshal(bz, &other))
-		require.True(t, tc.input.Equal(other))
+		s.Require().NoError(err)
+		s.Require().Equal(tc.jsonStr, string(bz))
+		s.Require().NoError(json.Unmarshal(bz, &other))
+		s.Require().True(tc.input.Equal(other))
 
 		bz, err = yaml.Marshal(tc.input)
-		require.NoError(t, err)
-		require.Equal(t, tc.yamlStr, string(bz))
+		s.Require().NoError(err)
+		s.Require().Equal(tc.yamlStr, string(bz))
 	}
 }
 
 func BenchmarkMarshalTo(b *testing.B) {
 	bis := []struct {
-		in   Dec
+		in   sdk.Dec
 		want []byte
 	}{
 		{
-			NewDec(1e8), []byte{
+			sdk.NewDec(1e8), []byte{
 				0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
 				0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
 				0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
 			},
 		},
-		{NewDec(0), []byte{0x30}},
+		{sdk.NewDec(0), []byte{0x30}},
 	}
 	data := make([]byte, 100)
 
diff --git a/types/denom_test.go b/types/denom_internal_test.go
similarity index 70%
rename from types/denom_test.go
rename to types/denom_internal_test.go
index de6437994b..e540b28d57 100644
--- a/types/denom_test.go
+++ b/types/denom_internal_test.go
@@ -3,7 +3,7 @@ package types
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 )
 
 var (
@@ -13,36 +13,44 @@ var (
 	natom = "natom" // 10^-9 (nano)
 )
 
-func TestRegisterDenom(t *testing.T) {
+type internalDenomTestSuite struct {
+	suite.Suite
+}
+
+func TestInternalDenomTestSuite(t *testing.T) {
+	suite.Run(t, new(internalDenomTestSuite))
+}
+
+func (s *internalDenomTestSuite) TestRegisterDenom() {
 	atomUnit := OneDec() // 1 (base denom unit)
 
-	require.NoError(t, RegisterDenom(atom, atomUnit))
-	require.Error(t, RegisterDenom(atom, atomUnit))
+	s.Require().NoError(RegisterDenom(atom, atomUnit))
+	s.Require().Error(RegisterDenom(atom, atomUnit))
 
 	res, ok := GetDenomUnit(atom)
-	require.True(t, ok)
-	require.Equal(t, atomUnit, res)
+	s.Require().True(ok)
+	s.Require().Equal(atomUnit, res)
 
 	res, ok = GetDenomUnit(matom)
-	require.False(t, ok)
-	require.Equal(t, ZeroDec(), res)
+	s.Require().False(ok)
+	s.Require().Equal(ZeroDec(), res)
 
 	// reset registration
 	denomUnits = map[string]Dec{}
 }
 
-func TestConvertCoins(t *testing.T) {
+func (s *internalDenomTestSuite) TestConvertCoins() {
 	atomUnit := OneDec() // 1 (base denom unit)
-	require.NoError(t, RegisterDenom(atom, atomUnit))
+	s.Require().NoError(RegisterDenom(atom, atomUnit))
 
 	matomUnit := NewDecWithPrec(1, 3) // 10^-3 (milli)
-	require.NoError(t, RegisterDenom(matom, matomUnit))
+	s.Require().NoError(RegisterDenom(matom, matomUnit))
 
 	uatomUnit := NewDecWithPrec(1, 6) // 10^-6 (micro)
-	require.NoError(t, RegisterDenom(uatom, uatomUnit))
+	s.Require().NoError(RegisterDenom(uatom, uatomUnit))
 
 	natomUnit := NewDecWithPrec(1, 9) // 10^-9 (nano)
-	require.NoError(t, RegisterDenom(natom, natomUnit))
+	s.Require().NoError(RegisterDenom(natom, natomUnit))
 
 	testCases := []struct {
 		input  Coin
@@ -68,12 +76,12 @@ func TestConvertCoins(t *testing.T) {
 
 	for i, tc := range testCases {
 		res, err := ConvertCoin(tc.input, tc.denom)
-		require.Equal(
-			t, tc.expErr, err != nil,
+		s.Require().Equal(
+			tc.expErr, err != nil,
 			"unexpected error; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
 		)
-		require.Equal(
-			t, tc.result, res,
+		s.Require().Equal(
+			tc.result, res,
 			"invalid result; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
 		)
 	}
diff --git a/types/events_test.go b/types/events_test.go
index ad8bf767aa..6aa6269837 100644
--- a/types/events_test.go
+++ b/types/events_test.go
@@ -1,77 +1,87 @@
-package types
+package types_test
 
 import (
 	"encoding/json"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 	abci "github.com/tendermint/tendermint/abci/types"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestAppendEvents(t *testing.T) {
-	e1 := NewEvent("transfer", NewAttribute("sender", "foo"))
-	e2 := NewEvent("transfer", NewAttribute("sender", "bar"))
-	a := Events{e1}
-	b := Events{e2}
+type eventsTestSuite struct {
+	suite.Suite
+}
+
+func TestEventsTestSuite(t *testing.T) {
+	suite.Run(t, new(eventsTestSuite))
+}
+
+func (s *eventsTestSuite) TestAppendEvents() {
+	e1 := sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))
+	e2 := sdk.NewEvent("transfer", sdk.NewAttribute("sender", "bar"))
+	a := sdk.Events{e1}
+	b := sdk.Events{e2}
 	c := a.AppendEvents(b)
-	require.Equal(t, c, Events{e1, e2})
-	require.Equal(t, c, Events{e1}.AppendEvent(NewEvent("transfer", NewAttribute("sender", "bar"))))
-	require.Equal(t, c, Events{e1}.AppendEvents(Events{e2}))
+	s.Require().Equal(c, sdk.Events{e1, e2})
+	s.Require().Equal(c, sdk.Events{e1}.AppendEvent(sdk.NewEvent("transfer", sdk.NewAttribute("sender", "bar"))))
+	s.Require().Equal(c, sdk.Events{e1}.AppendEvents(sdk.Events{e2}))
 }
 
-func TestAppendAttributes(t *testing.T) {
-	e := NewEvent("transfer", NewAttribute("sender", "foo"))
-	e = e.AppendAttributes(NewAttribute("recipient", "bar"))
-	require.Len(t, e.Attributes, 2)
-	require.Equal(t, e, NewEvent("transfer", NewAttribute("sender", "foo"), NewAttribute("recipient", "bar")))
+func (s *eventsTestSuite) TestAppendAttributes() {
+	e := sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))
+	e = e.AppendAttributes(sdk.NewAttribute("recipient", "bar"))
+	s.Require().Len(e.Attributes, 2)
+	s.Require().Equal(e, sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"), sdk.NewAttribute("recipient", "bar")))
 }
 
-func TestEmptyEvents(t *testing.T) {
-	require.Equal(t, EmptyEvents(), Events{})
+func (s *eventsTestSuite) TestEmptyEvents() {
+	s.Require().Equal(sdk.EmptyEvents(), sdk.Events{})
 }
 
-func TestAttributeString(t *testing.T) {
-	require.Equal(t, "foo: bar", NewAttribute("foo", "bar").String())
+func (s *eventsTestSuite) TestAttributeString() {
+	s.Require().Equal("foo: bar", sdk.NewAttribute("foo", "bar").String())
 }
 
-func TestToABCIEvents(t *testing.T) {
-	e := Events{NewEvent("transfer", NewAttribute("sender", "foo"))}
+func (s *eventsTestSuite) TestToABCIEvents() {
+	e := sdk.Events{sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))}
 	abciEvents := e.ToABCIEvents()
-	require.Len(t, abciEvents, 1)
-	require.Equal(t, abciEvents[0].Type, e[0].Type)
-	require.Equal(t, abciEvents[0].Attributes, e[0].Attributes)
+	s.Require().Len(abciEvents, 1)
+	s.Require().Equal(abciEvents[0].Type, e[0].Type)
+	s.Require().Equal(abciEvents[0].Attributes, e[0].Attributes)
 }
 
-func TestEventManager(t *testing.T) {
-	em := NewEventManager()
-	event := NewEvent("reward", NewAttribute("x", "y"))
-	events := Events{NewEvent("transfer", NewAttribute("sender", "foo"))}
+func (s *eventsTestSuite) TestEventManager() {
+	em := sdk.NewEventManager()
+	event := sdk.NewEvent("reward", sdk.NewAttribute("x", "y"))
+	events := sdk.Events{sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))}
 
 	em.EmitEvents(events)
 	em.EmitEvent(event)
 
-	require.Len(t, em.Events(), 2)
-	require.Equal(t, em.Events(), events.AppendEvent(event))
+	s.Require().Len(em.Events(), 2)
+	s.Require().Equal(em.Events(), events.AppendEvent(event))
 }
 
-func TestStringifyEvents(t *testing.T) {
-	e := Events{
-		NewEvent("message", NewAttribute("sender", "foo")),
-		NewEvent("message", NewAttribute("module", "bank")),
+func (s *eventsTestSuite) TestStringifyEvents() {
+	e := sdk.Events{
+		sdk.NewEvent("message", sdk.NewAttribute("sender", "foo")),
+		sdk.NewEvent("message", sdk.NewAttribute("module", "bank")),
 	}
-	se := StringifyEvents(e.ToABCIEvents())
+	se := sdk.StringifyEvents(e.ToABCIEvents())
 
 	expectedTxtStr := "\t\t- message\n\t\t\t- sender: foo\n\t\t\t- module: bank"
-	require.Equal(t, expectedTxtStr, se.String())
+	s.Require().Equal(expectedTxtStr, se.String())
 
 	bz, err := json.Marshal(se)
-	require.NoError(t, err)
+	s.Require().NoError(err)
 
 	expectedJSONStr := "[{\"type\":\"message\",\"attributes\":[{\"key\":\"sender\",\"value\":\"foo\"},{\"key\":\"module\",\"value\":\"bank\"}]}]"
-	require.Equal(t, expectedJSONStr, string(bz))
+	s.Require().Equal(expectedJSONStr, string(bz))
 }
 
-func TestMarkEventsToIndex(t *testing.T) {
+func (s *eventsTestSuite) TestMarkEventsToIndex() {
 	events := []abci.Event{
 		{
 			Type: "message",
@@ -166,8 +176,8 @@ func TestMarkEventsToIndex(t *testing.T) {
 
 	for name, tc := range testCases {
 		tc := tc
-		t.Run(name, func(t *testing.T) {
-			require.Equal(t, tc.expected, MarkEventsToIndex(tc.events, tc.indexSet))
+		s.T().Run(name, func(_ *testing.T) {
+			s.Require().Equal(tc.expected, sdk.MarkEventsToIndex(tc.events, tc.indexSet))
 		})
 	}
 }
diff --git a/types/invariant_test.go b/types/invariant_test.go
index fe59650115..8d5f507bb3 100644
--- a/types/invariant_test.go
+++ b/types/invariant_test.go
@@ -3,13 +3,20 @@ package types_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestFormatInvariant(t *testing.T) {
-	t.Parallel()
-	require.Equal(t, ":  invariant\n\n", sdk.FormatInvariant("", "", ""))
-	require.Equal(t, "module: name invariant\nmsg\n", sdk.FormatInvariant("module", "name", "msg"))
+type invariantTestSuite struct {
+	suite.Suite
+}
+
+func TestInvariantTestSuite(t *testing.T) {
+	suite.Run(t, new(invariantTestSuite))
+}
+
+func (s *invariantTestSuite) TestFormatInvariant() {
+	s.Require().Equal(":  invariant\n\n", sdk.FormatInvariant("", "", ""))
+	s.Require().Equal("module: name invariant\nmsg\n", sdk.FormatInvariant("module", "name", "msg"))
 }
diff --git a/types/result_test.go b/types/result_test.go
index faed16c869..448d04dc89 100644
--- a/types/result_test.go
+++ b/types/result_test.go
@@ -5,7 +5,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/bytes"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
@@ -14,33 +15,38 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestParseABCILog(t *testing.T) {
-	t.Parallel()
-	logs := `[{"log":"","msg_index":1,"success":true}]`
-
-	res, err := sdk.ParseABCILogs(logs)
-	require.NoError(t, err)
-	require.Len(t, res, 1)
-	require.Equal(t, res[0].Log, "")
-	require.Equal(t, res[0].MsgIndex, uint32(1))
+type resultTestStuite struct {
+	suite.Suite
 }
 
-func TestABCIMessageLog(t *testing.T) {
-	t.Parallel()
+func TestRTestStuite(t *testing.T) {
+	suite.Run(t, new(resultTestStuite))
+}
+
+func (s *resultTestStuite) TestParseABCILog() {
+	logs := `[{"log":"","msg_index":1,"success":true}]`
+	res, err := sdk.ParseABCILogs(logs)
+
+	s.Require().NoError(err)
+	s.Require().Len(res, 1)
+	s.Require().Equal(res[0].Log, "")
+	s.Require().Equal(res[0].MsgIndex, uint32(1))
+}
+
+func (s *resultTestStuite) TestABCIMessageLog() {
 	cdc := codec.NewLegacyAmino()
 	events := sdk.Events{sdk.NewEvent("transfer", sdk.NewAttribute("sender", "foo"))}
 	msgLog := sdk.NewABCIMessageLog(0, "", events)
-
 	msgLogs := sdk.ABCIMessageLogs{msgLog}
 	bz, err := cdc.MarshalJSON(msgLogs)
-	require.NoError(t, err)
-	require.Equal(t, string(bz), msgLogs.String())
+
+	s.Require().NoError(err)
+	s.Require().Equal(string(bz), msgLogs.String())
 }
 
-func TestNewSearchTxsResult(t *testing.T) {
-	t.Parallel()
+func (s *resultTestStuite) TestNewSearchTxsResult() {
 	got := sdk.NewSearchTxsResult(150, 20, 2, 20, []*sdk.TxResponse{})
-	require.Equal(t, &sdk.SearchTxsResult{
+	s.Require().Equal(&sdk.SearchTxsResult{
 		TotalCount: 150,
 		Count:      20,
 		PageNumber: 2,
@@ -50,21 +56,7 @@ func TestNewSearchTxsResult(t *testing.T) {
 	}, got)
 }
 
-/*
-	Codespace: res.TxResult.Codespace,
-	Code:      res.TxResult.Code,
-	Data:      strings.ToUpper(hex.EncodeToString(res.TxResult.Data)),
-	RawLog:    res.TxResult.Log,
-	Logs:      parsedLogs,
-	Info:      res.TxResult.Info,
-	GasWanted: res.TxResult.GasWanted,
-	GasUsed:   res.TxResult.GasUsed,
-	Tx:        tx,
-	Timestamp: timestamp,
-*/
-
-func TestResponseResultTx(t *testing.T) {
-	t.Parallel()
+func (s *resultTestStuite) TestResponseResultTx() {
 	deliverTxResult := abci.ResponseDeliverTx{
 		Codespace: "codespace",
 		Code:      1,
@@ -80,7 +72,9 @@ func TestResponseResultTx(t *testing.T) {
 		TxResult: deliverTxResult,
 	}
 	logs, err := sdk.ParseABCILogs(`[]`)
-	require.NoError(t, err)
+
+	s.Require().NoError(err)
+
 	want := &sdk.TxResponse{
 		TxHash:    "74657374",
 		Height:    10,
@@ -96,9 +90,9 @@ func TestResponseResultTx(t *testing.T) {
 		Timestamp: "timestamp",
 	}
 
-	require.Equal(t, want, sdk.NewResponseResultTx(resultTx, nil, "timestamp"))
-	require.Equal(t, (*sdk.TxResponse)(nil), sdk.NewResponseResultTx(nil, nil, "timestamp"))
-	require.Equal(t, `Response:
+	s.Require().Equal(want, sdk.NewResponseResultTx(resultTx, nil, "timestamp"))
+	s.Require().Equal((*sdk.TxResponse)(nil), sdk.NewResponseResultTx(nil, nil, "timestamp"))
+	s.Require().Equal(`Response:
   Height: 10
   TxHash: 74657374
   Code: 1
@@ -110,8 +104,8 @@ func TestResponseResultTx(t *testing.T) {
   GasUsed: 90
   Codespace: codespace
   Timestamp: timestamp`, sdk.NewResponseResultTx(resultTx, nil, "timestamp").String())
-	require.True(t, sdk.TxResponse{}.Empty())
-	require.False(t, want.Empty())
+	s.Require().True(sdk.TxResponse{}.Empty())
+	s.Require().False(want.Empty())
 
 	resultBroadcastTx := &ctypes.ResultBroadcastTx{
 		Code:      1,
@@ -120,7 +114,8 @@ func TestResponseResultTx(t *testing.T) {
 		Log:       `[]`,
 		Hash:      bytes.HexBytes([]byte("test")),
 	}
-	require.Equal(t, &sdk.TxResponse{
+
+	s.Require().Equal(&sdk.TxResponse{
 		Code:      1,
 		Codespace: "codespace",
 		Data:      "64617461",
@@ -128,16 +123,15 @@ func TestResponseResultTx(t *testing.T) {
 		Logs:      logs,
 		TxHash:    "74657374",
 	}, sdk.NewResponseFormatBroadcastTx(resultBroadcastTx))
-
-	require.Equal(t, (*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTx(nil))
+	s.Require().Equal((*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTx(nil))
 }
 
-func TestResponseFormatBroadcastTxCommit(t *testing.T) {
+func (s *resultTestStuite) TestResponseFormatBroadcastTxCommit() {
 	// test nil
-	require.Equal(t, (*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTxCommit(nil))
+	s.Require().Equal((*sdk.TxResponse)(nil), sdk.NewResponseFormatBroadcastTxCommit(nil))
 
 	logs, err := sdk.ParseABCILogs(`[]`)
-	require.NoError(t, err)
+	s.Require().NoError(err)
 
 	// test checkTx
 	checkTxResult := &ctypes.ResultBroadcastTxCommit{
@@ -166,7 +160,6 @@ func TestResponseFormatBroadcastTxCommit(t *testing.T) {
 			Codespace: "codespace",
 		},
 	}
-
 	want := &sdk.TxResponse{
 		Height:    10,
 		TxHash:    "74657374",
@@ -179,6 +172,7 @@ func TestResponseFormatBroadcastTxCommit(t *testing.T) {
 		GasWanted: 99,
 		GasUsed:   100,
 	}
-	require.Equal(t, want, sdk.NewResponseFormatBroadcastTxCommit(checkTxResult))
-	require.Equal(t, want, sdk.NewResponseFormatBroadcastTxCommit(deliverTxResult))
+
+	s.Require().Equal(want, sdk.NewResponseFormatBroadcastTxCommit(checkTxResult))
+	s.Require().Equal(want, sdk.NewResponseFormatBroadcastTxCommit(deliverTxResult))
 }
diff --git a/types/router_test.go b/types/router_test.go
index a3df95ae6a..79d340e8da 100644
--- a/types/router_test.go
+++ b/types/router_test.go
@@ -1,37 +1,47 @@
-package types
+package types_test
 
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestNilRoute(t *testing.T) {
+type routeTestSuite struct {
+	suite.Suite
+}
+
+func TestRouteTestSuite(t *testing.T) {
+	suite.Run(t, new(routeTestSuite))
+}
+
+func (s *routeTestSuite) TestNilRoute() {
 	tests := []struct {
 		name     string
-		route    Route
+		route    sdk.Route
 		expected bool
 	}{
 		{
 			name:     "all empty",
-			route:    NewRoute("", nil),
+			route:    sdk.NewRoute("", nil),
 			expected: true,
 		},
 		{
 			name:     "only path",
-			route:    NewRoute("some", nil),
+			route:    sdk.NewRoute("some", nil),
 			expected: true,
 		},
 		{
 			name: "only handler",
-			route: NewRoute("", func(ctx Context, msg Msg) (*Result, error) {
+			route: sdk.NewRoute("", func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 				return nil, nil
 			}),
 			expected: true,
 		},
 		{
 			name: "correct route",
-			route: NewRoute("some", func(ctx Context, msg Msg) (*Result, error) {
+			route: sdk.NewRoute("some", func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 				return nil, nil
 			}),
 			expected: false,
@@ -39,9 +49,6 @@ func TestNilRoute(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.expected, tt.route.Empty())
-		})
+		s.Require().Equal(tt.expected, tt.route.Empty())
 	}
 }
diff --git a/types/staking_test.go b/types/staking_test.go
index 537137971d..6033637891 100644
--- a/types/staking_test.go
+++ b/types/staking_test.go
@@ -3,22 +3,30 @@ package types_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestBondStatus(t *testing.T) {
-	require.False(t, sdk.Unbonded.Equal(sdk.Bonded))
-	require.False(t, sdk.Unbonded.Equal(sdk.Unbonding))
-	require.False(t, sdk.Bonded.Equal(sdk.Unbonding))
-	require.Panicsf(t, func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet
-	require.Equal(t, sdk.BondStatusUnbonded, sdk.Unbonded.String())
-	require.Equal(t, sdk.BondStatusBonded, sdk.Bonded.String())
-	require.Equal(t, sdk.BondStatusUnbonding, sdk.Unbonding.String())
+type stakingTestSuite struct {
+	suite.Suite
 }
 
-func TestTokensToConsensusPower(t *testing.T) {
-	require.Equal(t, int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999)))
-	require.Equal(t, int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000)))
+func TestStakingTestSuite(t *testing.T) {
+	suite.Run(t, new(stakingTestSuite))
+}
+
+func (s *stakingTestSuite) TestBondStatus() {
+	s.Require().False(sdk.Unbonded.Equal(sdk.Bonded))
+	s.Require().False(sdk.Unbonded.Equal(sdk.Unbonding))
+	s.Require().False(sdk.Bonded.Equal(sdk.Unbonding))
+	s.Require().Panicsf(func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet
+	s.Require().Equal(sdk.BondStatusUnbonded, sdk.Unbonded.String())
+	s.Require().Equal(sdk.BondStatusBonded, sdk.Bonded.String())
+	s.Require().Equal(sdk.BondStatusUnbonding, sdk.Unbonding.String())
+}
+
+func (s *stakingTestSuite) TestTokensToConsensusPower() {
+	s.Require().Equal(int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999)))
+	s.Require().Equal(int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000)))
 }
diff --git a/types/store_test.go b/types/store_test.go
index a4af3a663f..84e737570b 100644
--- a/types/store_test.go
+++ b/types/store_test.go
@@ -3,7 +3,7 @@ package types_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 	dbm "github.com/tendermint/tm-db"
 
 	"github.com/cosmos/cosmos-sdk/store/rootmulti"
@@ -11,7 +11,15 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestPrefixEndBytes(t *testing.T) {
+type storeTestSuite struct {
+	suite.Suite
+}
+
+func TestStoreTestSuite(t *testing.T) {
+	suite.Run(t, new(storeTestSuite))
+}
+
+func (s *storeTestSuite) TestPrefixEndBytes() {
 	var testCases = []struct {
 		prefix   []byte
 		expected []byte
@@ -27,69 +35,64 @@ func TestPrefixEndBytes(t *testing.T) {
 
 	for _, test := range testCases {
 		end := sdk.PrefixEndBytes(test.prefix)
-		require.Equal(t, test.expected, end)
+		s.Require().Equal(test.expected, end)
 	}
 }
 
-func TestCommitID(t *testing.T) {
+func (s *storeTestSuite) TestCommitID() {
 	var empty sdk.CommitID
-	require.True(t, empty.IsZero())
+	s.Require().True(empty.IsZero())
 
 	var nonempty = sdk.CommitID{
 		Version: 1,
 		Hash:    []byte("testhash"),
 	}
-	require.False(t, nonempty.IsZero())
+	s.Require().False(nonempty.IsZero())
 }
 
-func TestNewKVStoreKeys(t *testing.T) {
-	t.Parallel()
-	require.Equal(t, map[string]*sdk.KVStoreKey{}, sdk.NewKVStoreKeys())
-	require.Equal(t, 1, len(sdk.NewKVStoreKeys("one")))
+func (s *storeTestSuite) TestNewKVStoreKeys() {
+	s.Require().Equal(map[string]*sdk.KVStoreKey{}, sdk.NewKVStoreKeys())
+	s.Require().Equal(1, len(sdk.NewKVStoreKeys("one")))
 }
 
-func TestNewTransientStoreKeys(t *testing.T) {
-	t.Parallel()
-	require.Equal(t, map[string]*sdk.TransientStoreKey{}, sdk.NewTransientStoreKeys())
-	require.Equal(t, 1, len(sdk.NewTransientStoreKeys("one")))
+func (s *storeTestSuite) TestNewTransientStoreKeys() {
+	s.Require().Equal(map[string]*sdk.TransientStoreKey{}, sdk.NewTransientStoreKeys())
+	s.Require().Equal(1, len(sdk.NewTransientStoreKeys("one")))
 }
 
-func TestNewInfiniteGasMeter(t *testing.T) {
-	t.Parallel()
+func (s *storeTestSuite) TestNewInfiniteGasMeter() {
 	gm := sdk.NewInfiniteGasMeter()
-	require.NotNil(t, gm)
+	s.Require().NotNil(gm)
 	_, ok := gm.(types.GasMeter)
-	require.True(t, ok)
+	s.Require().True(ok)
 }
 
-func TestStoreTypes(t *testing.T) {
-	t.Parallel()
-	require.Equal(t, sdk.InclusiveEndBytes([]byte("endbytes")), types.InclusiveEndBytes([]byte("endbytes")))
+func (s *storeTestSuite) TestStoreTypes() {
+	s.Require().Equal(sdk.InclusiveEndBytes([]byte("endbytes")), types.InclusiveEndBytes([]byte("endbytes")))
 }
 
-func TestDiffKVStores(t *testing.T) {
-	t.Parallel()
-	store1, store2 := initTestStores(t)
+func (s *storeTestSuite) TestDiffKVStores() {
+	store1, store2 := s.initTestStores()
 	// Two equal stores
 	k1, v1 := []byte("k1"), []byte("v1")
 	store1.Set(k1, v1)
 	store2.Set(k1, v1)
 
-	checkDiffResults(t, store1, store2)
+	s.checkDiffResults(store1, store2)
 
 	// delete k1 from store2, which is now empty
 	store2.Delete(k1)
-	checkDiffResults(t, store1, store2)
+	s.checkDiffResults(store1, store2)
 
 	// set k1 in store2, different value than what store1 holds for k1
 	v2 := []byte("v2")
 	store2.Set(k1, v2)
-	checkDiffResults(t, store1, store2)
+	s.checkDiffResults(store1, store2)
 
 	// add k2 to store2
 	k2 := []byte("k2")
 	store2.Set(k2, v2)
-	checkDiffResults(t, store1, store2)
+	s.checkDiffResults(store1, store2)
 
 	// Reset stores
 	store1.Delete(k1)
@@ -101,24 +104,24 @@ func TestDiffKVStores(t *testing.T) {
 	k1Prefixed := append(prefix, k1...)
 	store1.Set(k1Prefixed, v1)
 	store2.Set(k1Prefixed, v2)
-	checkDiffResults(t, store1, store2)
+	s.checkDiffResults(store1, store2)
 }
 
-func initTestStores(t *testing.T) (types.KVStore, types.KVStore) {
+func (s *storeTestSuite) initTestStores() (types.KVStore, types.KVStore) {
 	db := dbm.NewMemDB()
 	ms := rootmulti.NewStore(db)
 
 	key1 := types.NewKVStoreKey("store1")
 	key2 := types.NewKVStoreKey("store2")
-	require.NotPanics(t, func() { ms.MountStoreWithDB(key1, types.StoreTypeIAVL, db) })
-	require.NotPanics(t, func() { ms.MountStoreWithDB(key2, types.StoreTypeIAVL, db) })
-	require.NoError(t, ms.LoadLatestVersion())
+	s.Require().NotPanics(func() { ms.MountStoreWithDB(key1, types.StoreTypeIAVL, db) })
+	s.Require().NotPanics(func() { ms.MountStoreWithDB(key2, types.StoreTypeIAVL, db) })
+	s.Require().NoError(ms.LoadLatestVersion())
 	return ms.GetKVStore(key1), ms.GetKVStore(key2)
 }
 
-func checkDiffResults(t *testing.T, store1, store2 types.KVStore) {
+func (s *storeTestSuite) checkDiffResults(store1, store2 types.KVStore) {
 	kvAs1, kvBs1 := sdk.DiffKVStores(store1, store2, nil)
 	kvAs2, kvBs2 := types.DiffKVStores(store1, store2, nil)
-	require.Equal(t, kvAs1, kvAs2)
-	require.Equal(t, kvBs1, kvBs2)
+	s.Require().Equal(kvAs1, kvAs2)
+	s.Require().Equal(kvBs1, kvBs2)
 }
diff --git a/types/tx_msg_test.go b/types/tx_msg_test.go
index 70a21bcad3..09b7880753 100644
--- a/types/tx_msg_test.go
+++ b/types/tx_msg_test.go
@@ -3,23 +3,29 @@ package types_test
 import (
 	"testing"
 
+	"github.com/stretchr/testify/suite"
+
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
-
-	"github.com/stretchr/testify/require"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func TestTestMsg(t *testing.T) {
-	t.Parallel()
+type msgTestSuite struct {
+	suite.Suite
+}
+
+func TestMsgTestSuite(t *testing.T) {
+	suite.Run(t, new(msgTestSuite))
+}
+
+func (s *msgTestSuite) TestTestMsg() {
 	addr := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	accAddr := sdk.AccAddress(addr)
 
 	msg := testdata.NewTestMsg(accAddr)
-	require.NotNil(t, msg)
-	require.Equal(t, "TestMsg", msg.Route())
-	require.Equal(t, "Test message", msg.Type())
-	require.Nil(t, msg.ValidateBasic())
-	require.NotPanics(t, func() { msg.GetSignBytes() })
-	require.Equal(t, []sdk.AccAddress{accAddr}, msg.GetSigners())
+	s.Require().NotNil(msg)
+	s.Require().Equal("TestMsg", msg.Route())
+	s.Require().Equal("Test message", msg.Type())
+	s.Require().Nil(msg.ValidateBasic())
+	s.Require().NotPanics(func() { msg.GetSignBytes() })
+	s.Require().Equal([]sdk.AccAddress{accAddr}, msg.GetSigners())
 }
diff --git a/x/genutil/utils.go b/x/genutil/utils.go
index 1daf76c1b7..5eea117187 100644
--- a/x/genutil/utils.go
+++ b/x/genutil/utils.go
@@ -5,13 +5,14 @@ import (
 	"path/filepath"
 	"time"
 
-	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/privval"
 	tmtypes "github.com/tendermint/tendermint/types"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 )
 
 // ExportGenesisFile creates and writes the genesis configuration to disk. An