From 061d055a09b1aa4653cb8ada3da367b248f425b4 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 30 Apr 2024 05:57:39 +0300
Subject: [PATCH 01/12] test(types/address): add more unit tests for the file
 types/address.go

---
 types/address_test.go | 123 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 122 insertions(+), 1 deletion(-)

diff --git a/types/address_test.go b/types/address_test.go
index 5d7fb78d80f4..e563c8cdf42d 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -58,6 +58,13 @@ func (s *addressTestSuite) testMarshal(original, res interface{}, marshal func()
 	s.Require().Equal(original, res)
 }
 
+func (s *addressTestSuite) testMarshalYAML(original, res interface{}, marshal func() (interface{}, error), unmarshal func([]byte) error) {
+	bz, err := marshal()
+	s.Require().Nil(err)
+	s.Require().Nil(unmarshal([]byte(bz.(string))))
+	s.Require().Equal(original, res)
+}
+
 func (s *addressTestSuite) TestEmptyAddresses() {
 	s.T().Parallel()
 	s.Require().Equal((types.AccAddress{}).String(), "")
@@ -133,6 +140,45 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 	s.Require().Equal(types.ErrEmptyHexAddress, err)
 }
 
+func (s *addressTestSuite) TestRandBech32AccAddrConsistencyYAML() {
+	pubBz := make([]byte, ed25519.PubKeySize)
+	pub := &ed25519.PubKey{Key: pubBz}
+
+	for i := 0; i < 1000; i++ {
+		_, err := rand.Read(pub.Key)
+		s.Require().NoError(err)
+		acc := types.AccAddress(pub.Address())
+		res := &types.AccAddress{}
+
+		s.testMarshalYAML(&acc, res, acc.MarshalYAML, res.UnmarshalYAML)
+		s.testMarshalYAML(&acc, res, acc.MarshalYAML, res.UnmarshalYAML)
+
+		str := acc.String()
+		*res, err = types.AccAddressFromBech32(str)
+		s.Require().Nil(err)
+		s.Require().Equal(acc, *res)
+
+		str = hex.EncodeToString(acc)
+		*res, err = types.AccAddressFromHexUnsafe(str)
+		s.Require().Nil(err)
+		s.Require().Equal(acc, *res)
+	}
+
+	for _, str := range invalidStrs {
+		_, err := types.AccAddressFromHexUnsafe(str)
+		s.Require().NotNil(err)
+
+		_, err = types.AccAddressFromBech32(str)
+		s.Require().NotNil(err)
+
+		err = (*types.AccAddress)(nil).UnmarshalYAML([]byte("\"" + str + "\""))
+		s.Require().NotNil(err)
+	}
+
+	_, err := types.AccAddressFromHexUnsafe("")
+	s.Require().Equal(types.ErrEmptyHexAddress, err)
+}
+
 // Test that the account address cache ignores the bech32 prefix setting, retrieving bech32 addresses from the cache.
 // This will cause the AccAddress.String() to print out unexpected prefixes if the config was changed between bech32 lookups.
 // See https://github.com/cosmos/cosmos-sdk/issues/15317.
@@ -507,7 +553,7 @@ func (s *addressTestSuite) TestGetFromBech32() {
 	s.Require().Equal("invalid Bech32 prefix; expected x, got cosmos", err.Error())
 }
 
-func (s *addressTestSuite) TestMustAccAddressFromBech32() {
+func (s *addressTestSuite) TestMustValAddressFromBech32() {
 	bech32PrefixValAddr := types.GetConfig().GetBech32ValidatorAddrPrefix()
 	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
 	address := types.MustBech32ifyAddressBytes(bech32PrefixValAddr, addr20byte)
@@ -519,3 +565,78 @@ func (s *addressTestSuite) TestMustAccAddressFromBech32() {
 
 	s.Require().Equal(valAddress1, valAddress2)
 }
+
+func (s *addressTestSuite) TestGetBech32PrefixAccPub() {
+	actual := types.GetBech32PrefixAccPub("")
+	s.Require().Equal(types.PrefixPublic, actual)
+
+	actual = types.GetBech32PrefixAccPub("cosmos")
+	expected := "cosmos" + types.PrefixPublic
+	s.Require().Equal(expected, actual)
+}
+
+func (s *addressTestSuite) TestGetBech32PrefixValAddress() {
+	actual := types.GetBech32PrefixValAddr("")
+	expected := types.PrefixValidator + types.PrefixOperator
+	s.Require().Equal(expected, actual)
+
+	actual = types.GetBech32PrefixValAddr("cosmos1")
+	expected = "cosmos1" + types.PrefixValidator + types.PrefixOperator
+	s.Require().Equal(expected, actual)
+}
+
+func (s *addressTestSuite) TestGetBech32PrefixValPub() {
+	actual := types.GetBech32PrefixValPub("")
+	expected := types.PrefixValidator + types.PrefixOperator + types.PrefixPublic
+	s.Require().Equal(expected, actual)
+
+	actual = types.GetBech32PrefixValPub("cosmos2")
+	expected = "cosmos2" + types.PrefixValidator + types.PrefixOperator + types.PrefixPublic
+	s.Require().Equal(expected, actual)
+}
+
+func (s *addressTestSuite) TestGetBech32PrefixConsAddr() {
+	actual := types.GetBech32PrefixConsAddr("")
+	expected := types.PrefixValidator + types.PrefixConsensus
+	s.Require().Equal(expected, actual)
+
+	actual = types.GetBech32PrefixConsAddr("cosmos3")
+	expected = "cosmos3" + types.PrefixValidator + types.PrefixConsensus
+	s.Require().Equal(expected, actual)
+}
+
+func (s *addressTestSuite) TestGetBech32PrefixConsPub() {
+	actual := types.GetBech32PrefixConsPub("")
+	expected := types.PrefixValidator + types.PrefixConsensus + types.PrefixPublic
+	s.Require().Equal(expected, actual)
+
+	actual = types.GetBech32PrefixConsPub("cosmos4")
+	expected = "cosmos4" + types.PrefixValidator + types.PrefixConsensus + types.PrefixPublic
+	s.Require().Equal(expected, actual)
+}
+
+func (s *addressTestSuite) TestMustAccAddressFromBech32() {
+	bech32PrefixAccAddr := types.GetConfig().GetBech32AccountAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
+
+	valAddress1, err := types.AccAddressFromBech32(address)
+	s.Require().Nil(err)
+
+	valAddress2 := types.MustAccAddressFromBech32(address)
+
+	s.Require().Equal(valAddress1, valAddress2)
+}
+
+func (s *addressTestSuite) TestMustAccAddressFromBech32Panic() {
+	s.Require().Panics(func() {
+		types.MustAccAddressFromBech32("no-valid")
+	})
+}
+
+func (s *addressTestSuite) TestUnmarshalJSONAccAddressFailed() {
+	addr := &types.AccAddress{}
+	err := addr.UnmarshalJSON([]byte{34, 34})
+	s.Require().NoError(err)
+	s.Require().Equal(&types.AccAddress{}, addr)
+}

From da45914e3fe731ccc425ab0f033201e621a88034 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 30 Apr 2024 07:26:11 +0300
Subject: [PATCH 02/12] add more test for format

---
 types/address_test.go | 58 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/types/address_test.go b/types/address_test.go
index e563c8cdf42d..8a86db8065f4 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"crypto/rand"
 	"encoding/hex"
+	"fmt"
 	mathrand "math/rand"
 	"strings"
 	"testing"
+	"unsafe"
 
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
@@ -635,8 +637,64 @@ func (s *addressTestSuite) TestMustAccAddressFromBech32Panic() {
 }
 
 func (s *addressTestSuite) TestUnmarshalJSONAccAddressFailed() {
+	addr := &types.AccAddress{}
+	err := addr.UnmarshalJSON(nil)
+	s.Require().Error(err)
+}
+
+func (s *addressTestSuite) TestUnmarshalJSONAccAddressWithEmptyString() {
 	addr := &types.AccAddress{}
 	err := addr.UnmarshalJSON([]byte{34, 34})
 	s.Require().NoError(err)
 	s.Require().Equal(&types.AccAddress{}, addr)
 }
+
+func (s *addressTestSuite) TestUnmarshalYAMLAccAddressFailed() {
+	malformedYAML := []byte("k:k:K:")
+	addr := &types.AccAddress{}
+	err := addr.UnmarshalYAML(malformedYAML)
+	s.Require().Error(err)
+}
+
+func (s *addressTestSuite) TestUnmarshalYAMLAccAddressWithEmptyString() {
+	addr := &types.AccAddress{}
+	err := addr.UnmarshalYAML([]byte{34, 34})
+	s.Require().NoError(err)
+	s.Require().Equal(&types.AccAddress{}, addr)
+}
+
+func (s *addressTestSuite) TestFormatAccAddress() {
+	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
+	s.Require().NoError(err)
+	ptr := uintptr(unsafe.Pointer(accAddr))
+	cases := []struct {
+		name     string
+		verb     rune
+		expected string
+	}{
+		{
+			name:     "Format AccAddress as string",
+			verb:     's',
+			expected: "cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut",
+		},
+		{
+			name:     "Format AccAddress as poinyer",
+			verb:     'p',
+			expected: ptr,
+		},
+		{
+			name:     "Format AccAddress as hexadecimal",
+			verb:     'p',
+			expected: "D38566A4A9F91334E9D04377B1A7A2C3E25E450C",
+		},
+	}
+
+	for _, tc := range cases {
+		s.T().Run(tc.name)
+	}
+
+	actual := fmt.Sprintf("%X", accAddr)
+	fmt.Println(actual)
+	// 0xc0006c8420
+	// D38566A4A9F91334E9D04377B1A7A2C3E25E450C
+}

From c19f5a8b2e2696d25137507d8e11d9405d368833 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 30 Apr 2024 08:15:51 +0300
Subject: [PATCH 03/12] add test cases fir val address

---
 types/address_test.go | 198 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 164 insertions(+), 34 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index 8a86db8065f4..f068d1a09b9b 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -5,15 +5,14 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 	mathrand "math/rand"
+	"sigs.k8s.io/yaml"
 	"strings"
 	"testing"
 	"unsafe"
 
-	"github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
-	"sigs.k8s.io/yaml"
-
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
@@ -568,6 +567,12 @@ func (s *addressTestSuite) TestMustValAddressFromBech32() {
 	s.Require().Equal(valAddress1, valAddress2)
 }
 
+func (s *addressTestSuite) TestMustValAddressFromBech32Panic() {
+	s.Require().Panics(func() {
+		types.MustValAddressFromBech32("")
+	})
+}
+
 func (s *addressTestSuite) TestGetBech32PrefixAccPub() {
 	actual := types.GetBech32PrefixAccPub("")
 	s.Require().Equal(types.PrefixPublic, actual)
@@ -663,38 +668,163 @@ func (s *addressTestSuite) TestUnmarshalYAMLAccAddressWithEmptyString() {
 	s.Require().Equal(&types.AccAddress{}, addr)
 }
 
-func (s *addressTestSuite) TestFormatAccAddress() {
+func (s *addressTestSuite) TestFormatAccAddressAsString() {
 	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
 	s.Require().NoError(err)
-	ptr := uintptr(unsafe.Pointer(accAddr))
-	cases := []struct {
-		name     string
-		verb     rune
-		expected string
-	}{
-		{
-			name:     "Format AccAddress as string",
-			verb:     's',
-			expected: "cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut",
-		},
-		{
-			name:     "Format AccAddress as poinyer",
-			verb:     'p',
-			expected: ptr,
-		},
-		{
-			name:     "Format AccAddress as hexadecimal",
-			verb:     'p',
-			expected: "D38566A4A9F91334E9D04377B1A7A2C3E25E450C",
-		},
-	}
 
-	for _, tc := range cases {
-		s.T().Run(tc.name)
-	}
+	actual := fmt.Sprintf("%s", accAddr)
+	s.Require().Equal("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut", actual)
+}
+
+func (s *addressTestSuite) TestFormatAccAddressAsPointer() {
+	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
+	s.Require().NoError(err)
+
+	ptrAddr := &accAddr
+	actual := fmt.Sprintf("%p", ptrAddr)
+	expected := uintptr(unsafe.Pointer(&accAddr))
+	s.Require().Equal(fmt.Sprintf("%X", expected), actual)
+}
+
+func (s *addressTestSuite) TestFormatAccAddressWhenVerbIsDifferentFromSOrP() {
+	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
+	s.Require().NoError(err)
+
+	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
+	expected := "D38566A4A9F91334E9D04377B1A7A2C3E25E450C"
 
-	actual := fmt.Sprintf("%X", accAddr)
-	fmt.Println(actual)
-	// 0xc0006c8420
-	// D38566A4A9F91334E9D04377B1A7A2C3E25E450C
+	// GENERAL
+	actual := fmt.Sprintf("%v", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%#v", accAddr)
+	s.Require().Equal(expected, actual)
+
+	// BOOLEAN
+	actual = fmt.Sprintf("%t", accAddr)
+	s.Require().Equal(expected, actual)
+
+	// INTEGERS
+	actual = fmt.Sprintf("%b", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%c", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%d", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%o", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%O", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%x", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%X", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%U", accAddr)
+	s.Require().Equal(expected, actual)
+
+	// Floating-point and complex constituents
+	actual = fmt.Sprintf("%e", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%E", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%f", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%F", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%g", accAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%G", accAddr)
+}
+
+func (s *addressTestSuite) TestUnmarshalJSONValAddressFailed() {
+	addr := &types.ValAddress{}
+	err := addr.UnmarshalJSON(nil)
+	s.Require().Error(err)
+}
+
+func (s *addressTestSuite) TestUnmarshalJSONValAddressWithEmptyString() {
+	addr := &types.ValAddress{}
+	err := addr.UnmarshalJSON([]byte{34, 34})
+	s.Require().NoError(err)
+	s.Require().Equal(&types.ValAddress{}, addr)
+}
+
+func (s *addressTestSuite) TestUnmarshalYAMLValAddressFailed() {
+	malformedYAML := []byte("k:k:K:")
+	addr := &types.ValAddress{}
+	err := addr.UnmarshalYAML(malformedYAML)
+	s.Require().Error(err)
+}
+
+func (s *addressTestSuite) TestUnmarshalYAMLValAddressWithEmptyString() {
+	addr := &types.AccAddress{}
+	err := addr.UnmarshalYAML([]byte{34, 34})
+	s.Require().NoError(err)
+	s.Require().Equal(&types.ValAddress{}, addr)
+}
+
+func (s *addressTestSuite) TestFormatValAddressAsString() {
+	accAddr, err := types.ValAddressFromBech32("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2")
+	s.Require().NoError(err)
+
+	actual := fmt.Sprintf("%s", accAddr)
+	s.Require().Equal("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2", actual)
+}
+
+func (s *addressTestSuite) TestFormatValAddressAsPointer() {
+	valAddr, err := types.ValAddressFromBech32("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2")
+	s.Require().NoError(err)
+
+	ptrAddr := &valAddr
+	actual := fmt.Sprintf("%p", ptrAddr)
+	expected := uintptr(unsafe.Pointer(&valAddr))
+	s.Require().Equal(fmt.Sprintf("%X", expected), actual)
+}
+
+func (s *addressTestSuite) TestFormatValAddressWhenVerbIsDifferentFromSOrP() {
+	valAddr, err := types.ValAddressFromBech32("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2")
+	s.Require().NoError(err)
+
+	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
+	expected := "000102030405060708090A0B0C0D0E0F10111213"
+
+	// GENERAL
+	actual := fmt.Sprintf("%v", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%#v", valAddr)
+	s.Require().Equal(expected, actual)
+
+	// BOOLEAN
+	actual = fmt.Sprintf("%t", valAddr)
+	s.Require().Equal(expected, actual)
+
+	// INTEGERS
+	actual = fmt.Sprintf("%b", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%c", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%d", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%o", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%O", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%x", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%X", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%U", valAddr)
+	s.Require().Equal(expected, actual)
+
+	// Floating-point and complex constituents
+	actual = fmt.Sprintf("%e", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%E", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%f", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%F", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%g", valAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%G", valAddr)
 }

From d70d29b38289b3b21075594fd73142d1add25839 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 30 Apr 2024 09:18:21 +0300
Subject: [PATCH 04/12] fix failing tests

---
 types/address_test.go | 123 ++++++++++++++++++++++++++++++++++++++----
 1 file changed, 114 insertions(+), 9 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index f068d1a09b9b..3c5fece1d337 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"github.com/cosmos/cosmos-sdk/types/bech32"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	mathrand "math/rand"
@@ -669,29 +670,37 @@ func (s *addressTestSuite) TestUnmarshalYAMLAccAddressWithEmptyString() {
 }
 
 func (s *addressTestSuite) TestFormatAccAddressAsString() {
-	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
-	s.Require().NoError(err)
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	accAddr := types.AccAddress(addr20byte)
 
 	actual := fmt.Sprintf("%s", accAddr)
-	s.Require().Equal("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut", actual)
+
+	hrp := types.GetConfig().GetBech32AccountAddrPrefix()
+	expected, err := bech32.ConvertAndEncode(hrp, addr20byte)
+	s.Require().NoError(err)
+	s.Require().Equal(expected, actual)
 }
 
 func (s *addressTestSuite) TestFormatAccAddressAsPointer() {
-	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
-	s.Require().NoError(err)
+	bech32PrefixAccAddr := types.GetConfig().GetBech32AccountAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
+	accAddr := types.MustAccAddressFromBech32(address)
 
 	ptrAddr := &accAddr
 	actual := fmt.Sprintf("%p", ptrAddr)
 	expected := uintptr(unsafe.Pointer(&accAddr))
-	s.Require().Equal(fmt.Sprintf("%X", expected), actual)
+	s.Require().Equal(fmt.Sprintf("0x%x", expected), actual)
 }
 
 func (s *addressTestSuite) TestFormatAccAddressWhenVerbIsDifferentFromSOrP() {
-	accAddr, err := types.AccAddressFromBech32("cosmos16wzkdf9flyfnf6wsgdmmrfazc039u3gv5y90ut")
-	s.Require().NoError(err)
+	bech32PrefixAccAddr := types.GetConfig().GetBech32AccountAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
+	accAddr := types.MustAccAddressFromBech32(address)
 
 	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := "D38566A4A9F91334E9D04377B1A7A2C3E25E450C"
+	expected := fmt.Sprintf("%X", types.AccAddress(addr20byte))
 
 	// GENERAL
 	actual := fmt.Sprintf("%v", accAddr)
@@ -828,3 +837,99 @@ func (s *addressTestSuite) TestFormatValAddressWhenVerbIsDifferentFromSOrP() {
 	s.Require().Equal(expected, actual)
 	actual = fmt.Sprintf("%G", valAddr)
 }
+
+/////////////////
+
+func (s *addressTestSuite) TestUnmarshalJSONConsAddressFailed() {
+	addr := &types.ConsAddress{}
+	err := addr.UnmarshalJSON(nil)
+	s.Require().Error(err)
+}
+
+func (s *addressTestSuite) TestUnmarshalJSONConsAddressWithEmptyString() {
+	addr := &types.ConsAddress{}
+	err := addr.UnmarshalJSON([]byte{34, 34})
+	s.Require().NoError(err)
+	s.Require().Equal(&types.ConsAddress{}, addr)
+}
+
+func (s *addressTestSuite) TestUnmarshalYAMLConsAddressFailed() {
+	malformedYAML := []byte("k:k:K:")
+	addr := &types.ConsAddress{}
+	err := addr.UnmarshalYAML(malformedYAML)
+	s.Require().Error(err)
+}
+
+func (s *addressTestSuite) TestUnmarshalYAMLConsAddressWithEmptyString() {
+	addr := &types.ConsAddress{}
+	err := addr.UnmarshalYAML([]byte{34, 34})
+	s.Require().NoError(err)
+	s.Require().Equal(&types.ConsAddress{}, addr)
+}
+
+func (s *addressTestSuite) TestFormatConsAddressAsString() {
+	consAddr, err := types.ConsAddressFromBech32("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7")
+	s.Require().NoError(err)
+
+	actual := fmt.Sprintf("%s", consAddr)
+	s.Require().Equal("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7", actual)
+}
+
+func (s *addressTestSuite) TestFormatConsAddressAsPointer() {
+	consAddr, err := types.ConsAddressFromBech32("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7")
+	s.Require().NoError(err)
+
+	ptrAddr := &consAddr
+	actual := fmt.Sprintf("%p", ptrAddr)
+	expected := uintptr(unsafe.Pointer(&consAddr))
+	s.Require().Equal(fmt.Sprintf("%X", expected), actual)
+}
+
+func (s *addressTestSuite) TestFormatConsAddressWhenVerbIsDifferentFromSOrP() {
+	consAddr, err := types.ConsAddressFromBech32("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7")
+	s.Require().NoError(err)
+
+	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
+	expected := "1C54E513C590FC51F1299131BCA49E3601C345EC"
+
+	// GENERAL
+	actual := fmt.Sprintf("%v", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%#v", consAddr)
+	s.Require().Equal(expected, actual)
+
+	// BOOLEAN
+	actual = fmt.Sprintf("%t", consAddr)
+	s.Require().Equal(expected, actual)
+
+	// INTEGERS
+	actual = fmt.Sprintf("%b", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%c", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%d", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%o", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%O", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%x", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%X", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%U", consAddr)
+	s.Require().Equal(expected, actual)
+
+	// Floating-point and complex constituents
+	actual = fmt.Sprintf("%e", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%E", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%f", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%F", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%g", consAddr)
+	s.Require().Equal(expected, actual)
+	actual = fmt.Sprintf("%G", consAddr)
+}

From cfdf494894523c4fe14a72919f3a63daa4c0b71c Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Wed, 1 May 2024 15:40:33 +0300
Subject: [PATCH 05/12] add test cases for addrress type

---
 types/address_test.go | 74 ++++++++++++++++++++++++++-----------------
 1 file changed, 45 insertions(+), 29 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index 3c5fece1d337..898d2a60b724 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -628,12 +628,11 @@ func (s *addressTestSuite) TestMustAccAddressFromBech32() {
 	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
 	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
 
-	valAddress1, err := types.AccAddressFromBech32(address)
-	s.Require().Nil(err)
-
-	valAddress2 := types.MustAccAddressFromBech32(address)
+	accAddress1, err := types.AccAddressFromBech32(address)
+	s.Require().NoError(err)
 
-	s.Require().Equal(valAddress1, valAddress2)
+	accAddress2 := types.MustAccAddressFromBech32(address)
+	s.Require().Equal(accAddress1, accAddress2)
 }
 
 func (s *addressTestSuite) TestMustAccAddressFromBech32Panic() {
@@ -673,7 +672,7 @@ func (s *addressTestSuite) TestFormatAccAddressAsString() {
 	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
 	accAddr := types.AccAddress(addr20byte)
 
-	actual := fmt.Sprintf("%s", accAddr)
+	actual := fmt.Sprintf("%s", accAddr) // this will call internally  the method AccAddress.Format
 
 	hrp := types.GetConfig().GetBech32AccountAddrPrefix()
 	expected, err := bech32.ConvertAndEncode(hrp, addr20byte)
@@ -688,7 +687,7 @@ func (s *addressTestSuite) TestFormatAccAddressAsPointer() {
 	accAddr := types.MustAccAddressFromBech32(address)
 
 	ptrAddr := &accAddr
-	actual := fmt.Sprintf("%p", ptrAddr)
+	actual := fmt.Sprintf("%p", ptrAddr) // this will call internally  the method AccAddress.Format
 	expected := uintptr(unsafe.Pointer(&accAddr))
 	s.Require().Equal(fmt.Sprintf("0x%x", expected), actual)
 }
@@ -700,7 +699,7 @@ func (s *addressTestSuite) TestFormatAccAddressWhenVerbIsDifferentFromSOrP() {
 	accAddr := types.MustAccAddressFromBech32(address)
 
 	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := fmt.Sprintf("%X", types.AccAddress(addr20byte))
+	expected := fmt.Sprintf("%X", addr20byte)
 
 	// GENERAL
 	actual := fmt.Sprintf("%v", accAddr)
@@ -765,36 +764,44 @@ func (s *addressTestSuite) TestUnmarshalYAMLValAddressFailed() {
 }
 
 func (s *addressTestSuite) TestUnmarshalYAMLValAddressWithEmptyString() {
-	addr := &types.AccAddress{}
+	addr := &types.ValAddress{}
 	err := addr.UnmarshalYAML([]byte{34, 34})
 	s.Require().NoError(err)
 	s.Require().Equal(&types.ValAddress{}, addr)
 }
 
 func (s *addressTestSuite) TestFormatValAddressAsString() {
-	accAddr, err := types.ValAddressFromBech32("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2")
-	s.Require().NoError(err)
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	accAddr := types.ValAddress(addr20byte)
 
 	actual := fmt.Sprintf("%s", accAddr)
-	s.Require().Equal("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2", actual)
+
+	hrp := types.GetConfig().GetBech32ValidatorAddrPrefix()
+	expected, err := bech32.ConvertAndEncode(hrp, addr20byte)
+	s.Require().NoError(err)
+	s.Require().Equal(expected, actual)
 }
 
 func (s *addressTestSuite) TestFormatValAddressAsPointer() {
-	valAddr, err := types.ValAddressFromBech32("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2")
-	s.Require().NoError(err)
+	bech32PrefixValAddr := types.GetConfig().GetBech32ValidatorAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixValAddr, addr20byte)
+	accAddr := types.MustValAddressFromBech32(address)
 
-	ptrAddr := &valAddr
+	ptrAddr := &accAddr
 	actual := fmt.Sprintf("%p", ptrAddr)
-	expected := uintptr(unsafe.Pointer(&valAddr))
-	s.Require().Equal(fmt.Sprintf("%X", expected), actual)
+	expected := uintptr(unsafe.Pointer(&accAddr))
+	s.Require().Equal(fmt.Sprintf("0x%x", expected), actual)
 }
 
 func (s *addressTestSuite) TestFormatValAddressWhenVerbIsDifferentFromSOrP() {
-	valAddr, err := types.ValAddressFromBech32("cosmosvaloper1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnxz90a2")
-	s.Require().NoError(err)
+	bech32PrefixValAddr := types.GetConfig().GetBech32ValidatorAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixValAddr, addr20byte)
+	valAddr := types.MustValAddressFromBech32(address)
 
 	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := "000102030405060708090A0B0C0D0E0F10111213"
+	expected := fmt.Sprintf("%X", types.AccAddress(addr20byte))
 
 	// GENERAL
 	actual := fmt.Sprintf("%v", valAddr)
@@ -838,8 +845,6 @@ func (s *addressTestSuite) TestFormatValAddressWhenVerbIsDifferentFromSOrP() {
 	actual = fmt.Sprintf("%G", valAddr)
 }
 
-/////////////////
-
 func (s *addressTestSuite) TestUnmarshalJSONConsAddressFailed() {
 	addr := &types.ConsAddress{}
 	err := addr.UnmarshalJSON(nil)
@@ -868,29 +873,40 @@ func (s *addressTestSuite) TestUnmarshalYAMLConsAddressWithEmptyString() {
 }
 
 func (s *addressTestSuite) TestFormatConsAddressAsString() {
-	consAddr, err := types.ConsAddressFromBech32("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7")
-	s.Require().NoError(err)
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	consAddr := types.ConsAddress(addr20byte)
 
 	actual := fmt.Sprintf("%s", consAddr)
-	s.Require().Equal("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7", actual)
+
+	hrp := types.GetConfig().GetBech32ConsensusAddrPrefix()
+	expected, err := bech32.ConvertAndEncode(hrp, addr20byte)
+	s.Require().NoError(err)
+	s.Require().Equal(expected, actual)
 }
 
 func (s *addressTestSuite) TestFormatConsAddressAsPointer() {
-	consAddr, err := types.ConsAddressFromBech32("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7")
+	bech32PrefixConsAddr := types.GetConfig().GetBech32ConsensusAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixConsAddr, addr20byte)
+
+	consAddr, err := types.ConsAddressFromBech32(address)
 	s.Require().NoError(err)
 
 	ptrAddr := &consAddr
 	actual := fmt.Sprintf("%p", ptrAddr)
 	expected := uintptr(unsafe.Pointer(&consAddr))
-	s.Require().Equal(fmt.Sprintf("%X", expected), actual)
+	s.Require().Equal(fmt.Sprintf("0x%x", expected), actual)
 }
 
 func (s *addressTestSuite) TestFormatConsAddressWhenVerbIsDifferentFromSOrP() {
-	consAddr, err := types.ConsAddressFromBech32("cosmosvalcons1r32w2y79jr79ruffjycmefy7xcqux30vnk4dr7")
+	bech32PrefixAccAddr := types.GetConfig().GetBech32ConsensusAddrPrefix()
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
+	consAddr, err := types.ConsAddressFromBech32(address)
 	s.Require().NoError(err)
 
 	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := "1C54E513C590FC51F1299131BCA49E3601C345EC"
+	expected := fmt.Sprintf("%X", types.AccAddress(addr20byte))
 
 	// GENERAL
 	actual := fmt.Sprintf("%v", consAddr)

From 2c45c4e24411e53d63f93f03415f40d112e776ce Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Wed, 1 May 2024 15:47:27 +0300
Subject: [PATCH 06/12] fix lint

---
 types/address_test.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index 898d2a60b724..46ee2dee9c3f 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -5,19 +5,22 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
-	"github.com/cosmos/cosmos-sdk/types/bech32"
-	"github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
 	mathrand "math/rand"
-	"sigs.k8s.io/yaml"
 	"strings"
 	"testing"
 	"unsafe"
 
+
+
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"sigs.k8s.io/yaml"
+
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	"github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/bech32"
 	"github.com/cosmos/cosmos-sdk/types/bech32/legacybech32" //nolint:staticcheck // we're using this to support the legacy way of dealing with bech32
 )
 

From e454d892a03738bf6b66875e955411bcc9c5ef85 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Fri, 10 May 2024 10:57:43 +0300
Subject: [PATCH 07/12] fix comments

---
 types/address_test.go | 273 +++++++++---------------------------------
 1 file changed, 54 insertions(+), 219 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index 46ee2dee9c3f..2a2568a5220b 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -10,8 +10,6 @@ import (
 	"testing"
 	"unsafe"
 
-
-
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	"sigs.k8s.io/yaml"
@@ -58,15 +56,15 @@ var invalidStrs = []string{
 
 func (s *addressTestSuite) testMarshal(original, res interface{}, marshal func() ([]byte, error), unmarshal func([]byte) error) {
 	bz, err := marshal()
-	s.Require().Nil(err)
-	s.Require().Nil(unmarshal(bz))
+	s.Require().NoError(err)
+	s.Require().NoError(unmarshal(bz))
 	s.Require().Equal(original, res)
 }
 
 func (s *addressTestSuite) testMarshalYAML(original, res interface{}, marshal func() (interface{}, error), unmarshal func([]byte) error) {
 	bz, err := marshal()
-	s.Require().Nil(err)
-	s.Require().Nil(unmarshal([]byte(bz.(string))))
+	s.Require().NoError(err)
+	s.Require().NoError(unmarshal([]byte(bz.(string))))
 	s.Require().Equal(original, res)
 }
 
@@ -121,12 +119,12 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 
 		str := acc.String()
 		res, err = types.AccAddressFromBech32(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, res)
 
 		str = hex.EncodeToString(acc)
 		res, err = types.AccAddressFromHexUnsafe(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, res)
 	}
 
@@ -160,12 +158,12 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistencyYAML() {
 
 		str := acc.String()
 		*res, err = types.AccAddressFromBech32(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, *res)
 
 		str = hex.EncodeToString(acc)
 		*res, err = types.AccAddressFromHexUnsafe(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, *res)
 	}
 
@@ -270,12 +268,12 @@ func (s *addressTestSuite) TestValAddr() {
 
 		str := acc.String()
 		res, err = types.ValAddressFromBech32(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, res)
 
 		str = hex.EncodeToString(acc)
 		res, err = types.ValAddressFromHex(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, res)
 
 	}
@@ -311,12 +309,12 @@ func (s *addressTestSuite) TestConsAddress() {
 
 		str := acc.String()
 		res, err = types.ConsAddressFromBech32(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, res)
 
 		str = hex.EncodeToString(acc)
 		res, err = types.ConsAddressFromHex(str)
-		s.Require().Nil(err)
+		s.Require().NoError(err)
 		s.Require().Equal(acc, res)
 	}
 
@@ -418,13 +416,13 @@ func (s *addressTestSuite) TestAddressInterface() {
 		switch addr := addr.(type) {
 		case types.AccAddress:
 			_, err := types.AccAddressFromBech32(addr.String())
-			s.Require().Nil(err)
+			s.Require().NoError(err)
 		case types.ValAddress:
 			_, err := types.ValAddressFromBech32(addr.String())
-			s.Require().Nil(err)
+			s.Require().NoError(err)
 		case types.ConsAddress:
 			_, err := types.ConsAddressFromBech32(addr.String())
-			s.Require().Nil(err)
+			s.Require().NoError(err)
 		default:
 			s.T().Fail()
 		}
@@ -559,14 +557,8 @@ func (s *addressTestSuite) TestGetFromBech32() {
 }
 
 func (s *addressTestSuite) TestMustValAddressFromBech32() {
-	bech32PrefixValAddr := types.GetConfig().GetBech32ValidatorAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixValAddr, addr20byte)
-
-	valAddress1, err := types.ValAddressFromBech32(address)
-	s.Require().Nil(err)
-
-	valAddress2 := types.MustValAddressFromBech32(address)
+	valAddress1 := types.ValAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	valAddress2 := types.MustValAddressFromBech32(valAddress1.String())
 
 	s.Require().Equal(valAddress1, valAddress2)
 }
@@ -579,62 +571,47 @@ func (s *addressTestSuite) TestMustValAddressFromBech32Panic() {
 
 func (s *addressTestSuite) TestGetBech32PrefixAccPub() {
 	actual := types.GetBech32PrefixAccPub("")
-	s.Require().Equal(types.PrefixPublic, actual)
+	s.Require().Equal("pub", actual)
 
 	actual = types.GetBech32PrefixAccPub("cosmos")
-	expected := "cosmos" + types.PrefixPublic
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("cosmospub", actual)
 }
 
 func (s *addressTestSuite) TestGetBech32PrefixValAddress() {
 	actual := types.GetBech32PrefixValAddr("")
-	expected := types.PrefixValidator + types.PrefixOperator
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("valoper", actual)
 
 	actual = types.GetBech32PrefixValAddr("cosmos1")
-	expected = "cosmos1" + types.PrefixValidator + types.PrefixOperator
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("cosmos1valoper", actual)
 }
 
 func (s *addressTestSuite) TestGetBech32PrefixValPub() {
 	actual := types.GetBech32PrefixValPub("")
-	expected := types.PrefixValidator + types.PrefixOperator + types.PrefixPublic
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("valoperpub", actual)
 
 	actual = types.GetBech32PrefixValPub("cosmos2")
-	expected = "cosmos2" + types.PrefixValidator + types.PrefixOperator + types.PrefixPublic
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("cosmos2valoperpub", actual)
 }
 
 func (s *addressTestSuite) TestGetBech32PrefixConsAddr() {
 	actual := types.GetBech32PrefixConsAddr("")
-	expected := types.PrefixValidator + types.PrefixConsensus
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("valcons", actual)
 
 	actual = types.GetBech32PrefixConsAddr("cosmos3")
-	expected = "cosmos3" + types.PrefixValidator + types.PrefixConsensus
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("cosmos3valcons", actual)
 }
 
 func (s *addressTestSuite) TestGetBech32PrefixConsPub() {
 	actual := types.GetBech32PrefixConsPub("")
-	expected := types.PrefixValidator + types.PrefixConsensus + types.PrefixPublic
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("valconspub", actual)
 
 	actual = types.GetBech32PrefixConsPub("cosmos4")
-	expected = "cosmos4" + types.PrefixValidator + types.PrefixConsensus + types.PrefixPublic
-	s.Require().Equal(expected, actual)
+	s.Require().Equal("cosmos4valconspub", actual)
 }
 
 func (s *addressTestSuite) TestMustAccAddressFromBech32() {
-	bech32PrefixAccAddr := types.GetConfig().GetBech32AccountAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
-
-	accAddress1, err := types.AccAddressFromBech32(address)
-	s.Require().NoError(err)
-
-	accAddress2 := types.MustAccAddressFromBech32(address)
+	accAddress1 := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	accAddress2 := types.MustAccAddressFromBech32(accAddress1.String())
 	s.Require().Equal(accAddress1, accAddress2)
 }
 
@@ -684,66 +661,20 @@ func (s *addressTestSuite) TestFormatAccAddressAsString() {
 }
 
 func (s *addressTestSuite) TestFormatAccAddressAsPointer() {
-	bech32PrefixAccAddr := types.GetConfig().GetBech32AccountAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
-	accAddr := types.MustAccAddressFromBech32(address)
-
+	accAddr := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
 	ptrAddr := &accAddr
 	actual := fmt.Sprintf("%p", ptrAddr) // this will call internally  the method AccAddress.Format
-	expected := uintptr(unsafe.Pointer(&accAddr))
-	s.Require().Equal(fmt.Sprintf("0x%x", expected), actual)
+	expected := fmt.Sprintf("0x%x", uintptr(unsafe.Pointer(&accAddr)))
+	s.Require().Equal(expected, actual)
 }
 
 func (s *addressTestSuite) TestFormatAccAddressWhenVerbIsDifferentFromSOrP() {
-	bech32PrefixAccAddr := types.GetConfig().GetBech32AccountAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
-	accAddr := types.MustAccAddressFromBech32(address)
-
-	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := fmt.Sprintf("%X", addr20byte)
-
-	// GENERAL
-	actual := fmt.Sprintf("%v", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%#v", accAddr)
-	s.Require().Equal(expected, actual)
-
-	// BOOLEAN
-	actual = fmt.Sprintf("%t", accAddr)
-	s.Require().Equal(expected, actual)
-
-	// INTEGERS
-	actual = fmt.Sprintf("%b", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%c", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%d", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%o", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%O", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%x", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%X", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%U", accAddr)
-	s.Require().Equal(expected, actual)
-
-	// Floating-point and complex constituents
-	actual = fmt.Sprintf("%e", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%E", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%f", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%F", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%g", accAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%G", accAddr)
+	myAddr := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	exp := "000102030405060708090A0B0C0D0E0F10111213"
+	spec := []string{"%v", "%#v", "%t", "%b", "%c", "%d", "%o", "%O", "%x", "%X", "%U", "%e", "%E", "%f", "%F", "%g", "%G"}
+	for _, v := range spec {
+		s.Require().Equal(exp, fmt.Sprintf(v, myAddr), v)
+	}
 }
 
 func (s *addressTestSuite) TestUnmarshalJSONValAddressFailed() {
@@ -786,11 +717,7 @@ func (s *addressTestSuite) TestFormatValAddressAsString() {
 }
 
 func (s *addressTestSuite) TestFormatValAddressAsPointer() {
-	bech32PrefixValAddr := types.GetConfig().GetBech32ValidatorAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixValAddr, addr20byte)
-	accAddr := types.MustValAddressFromBech32(address)
-
+	accAddr := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
 	ptrAddr := &accAddr
 	actual := fmt.Sprintf("%p", ptrAddr)
 	expected := uintptr(unsafe.Pointer(&accAddr))
@@ -798,54 +725,12 @@ func (s *addressTestSuite) TestFormatValAddressAsPointer() {
 }
 
 func (s *addressTestSuite) TestFormatValAddressWhenVerbIsDifferentFromSOrP() {
-	bech32PrefixValAddr := types.GetConfig().GetBech32ValidatorAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixValAddr, addr20byte)
-	valAddr := types.MustValAddressFromBech32(address)
-
-	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := fmt.Sprintf("%X", types.AccAddress(addr20byte))
-
-	// GENERAL
-	actual := fmt.Sprintf("%v", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%#v", valAddr)
-	s.Require().Equal(expected, actual)
-
-	// BOOLEAN
-	actual = fmt.Sprintf("%t", valAddr)
-	s.Require().Equal(expected, actual)
-
-	// INTEGERS
-	actual = fmt.Sprintf("%b", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%c", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%d", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%o", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%O", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%x", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%X", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%U", valAddr)
-	s.Require().Equal(expected, actual)
-
-	// Floating-point and complex constituents
-	actual = fmt.Sprintf("%e", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%E", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%f", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%F", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%g", valAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%G", valAddr)
+	myAddr := types.ValAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	exp := "000102030405060708090A0B0C0D0E0F10111213"
+	spec := []string{"%v", "%#v", "%t", "%b", "%c", "%d", "%o", "%O", "%x", "%X", "%U", "%e", "%E", "%f", "%F", "%g", "%G"}
+	for _, v := range spec {
+		s.Require().Equal(exp, fmt.Sprintf(v, myAddr), v)
+	}
 }
 
 func (s *addressTestSuite) TestUnmarshalJSONConsAddressFailed() {
@@ -876,24 +761,17 @@ func (s *addressTestSuite) TestUnmarshalYAMLConsAddressWithEmptyString() {
 }
 
 func (s *addressTestSuite) TestFormatConsAddressAsString() {
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	consAddr := types.ConsAddress(addr20byte)
-
+	consAddr := types.ConsAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
 	actual := fmt.Sprintf("%s", consAddr)
 
 	hrp := types.GetConfig().GetBech32ConsensusAddrPrefix()
-	expected, err := bech32.ConvertAndEncode(hrp, addr20byte)
+	expected, err := bech32.ConvertAndEncode(hrp, consAddr)
 	s.Require().NoError(err)
 	s.Require().Equal(expected, actual)
 }
 
 func (s *addressTestSuite) TestFormatConsAddressAsPointer() {
-	bech32PrefixConsAddr := types.GetConfig().GetBech32ConsensusAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixConsAddr, addr20byte)
-
-	consAddr, err := types.ConsAddressFromBech32(address)
-	s.Require().NoError(err)
+	consAddr := types.ConsAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
 
 	ptrAddr := &consAddr
 	actual := fmt.Sprintf("%p", ptrAddr)
@@ -902,53 +780,10 @@ func (s *addressTestSuite) TestFormatConsAddressAsPointer() {
 }
 
 func (s *addressTestSuite) TestFormatConsAddressWhenVerbIsDifferentFromSOrP() {
-	bech32PrefixAccAddr := types.GetConfig().GetBech32ConsensusAddrPrefix()
-	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
-	address := types.MustBech32ifyAddressBytes(bech32PrefixAccAddr, addr20byte)
-	consAddr, err := types.ConsAddressFromBech32(address)
-	s.Require().NoError(err)
-
-	// When the verb is different from 's' or 'p', then the address is always formatted to base 16, with uppercase letters for A-F
-	expected := fmt.Sprintf("%X", types.AccAddress(addr20byte))
-
-	// GENERAL
-	actual := fmt.Sprintf("%v", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%#v", consAddr)
-	s.Require().Equal(expected, actual)
-
-	// BOOLEAN
-	actual = fmt.Sprintf("%t", consAddr)
-	s.Require().Equal(expected, actual)
-
-	// INTEGERS
-	actual = fmt.Sprintf("%b", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%c", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%d", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%o", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%O", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%x", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%X", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%U", consAddr)
-	s.Require().Equal(expected, actual)
-
-	// Floating-point and complex constituents
-	actual = fmt.Sprintf("%e", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%E", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%f", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%F", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%g", consAddr)
-	s.Require().Equal(expected, actual)
-	actual = fmt.Sprintf("%G", consAddr)
+	myAddr := types.ConsAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	exp := "000102030405060708090A0B0C0D0E0F10111213"
+	spec := []string{"%v", "%#v", "%t", "%b", "%c", "%d", "%o", "%O", "%x", "%X", "%U", "%e", "%E", "%f", "%F", "%g", "%G"}
+	for _, v := range spec {
+		s.Require().Equal(exp, fmt.Sprintf(v, myAddr), v)
+	}
 }

From 2c488cf89de72ea6dd6f23ae940657be6e96290d Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Fri, 10 May 2024 13:51:35 +0300
Subject: [PATCH 08/12] fix comments

---
 types/address_test.go | 45 ++++++++++++++++++++++++++-----------------
 1 file changed, 27 insertions(+), 18 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index 2a2568a5220b..f5c3c4aafe23 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"github.com/stretchr/testify/assert"
 	mathrand "math/rand"
 	"strings"
 	"testing"
@@ -61,11 +62,12 @@ func (s *addressTestSuite) testMarshal(original, res interface{}, marshal func()
 	s.Require().Equal(original, res)
 }
 
-func (s *addressTestSuite) testMarshalYAML(original, res interface{}, marshal func() (interface{}, error), unmarshal func([]byte) error) {
+func testMarshalYAML(t *testing.T, original, res interface{}, marshal func() (interface{}, error), unmarshal func([]byte) error) {
 	bz, err := marshal()
-	s.Require().NoError(err)
-	s.Require().NoError(unmarshal([]byte(bz.(string))))
-	s.Require().Equal(original, res)
+
+	assert.NoError(t, err)
+	assert.NoError(t, unmarshal([]byte(bz.(string))))
+	assert.Equal(t, original, res)
 }
 
 func (s *addressTestSuite) TestEmptyAddresses() {
@@ -143,29 +145,36 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 	s.Require().Equal(types.ErrEmptyHexAddress, err)
 }
 
-func (s *addressTestSuite) TestRandBech32AccAddrConsistencyYAML() {
-	pubBz := make([]byte, ed25519.PubKeySize)
-	pub := &ed25519.PubKey{Key: pubBz}
+func FuzzBech32AccAddrConsistencyYAML(f *testing.F) {
+	if testing.Short() {
+		f.Skip("running in -short mode")
+	}
 
-	for i := 0; i < 1000; i++ {
-		_, err := rand.Read(pub.Key)
-		s.Require().NoError(err)
-		acc := types.AccAddress(pub.Address())
+	f.Add([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	f.Add([]byte{16, 1, 2, 3, 4, 5, 16, 27, 58, 9, 51, 11, 12, 13, 14, 15, 16, 17, 20, 21})
+	f.Add([]byte{19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0})
+
+	f.Fuzz(func(t *testing.T, input []byte) {
+		acc := types.AccAddress(input)
 		res := &types.AccAddress{}
 
-		s.testMarshalYAML(&acc, res, acc.MarshalYAML, res.UnmarshalYAML)
-		s.testMarshalYAML(&acc, res, acc.MarshalYAML, res.UnmarshalYAML)
+		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
+		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
 
 		str := acc.String()
+		var err error
 		*res, err = types.AccAddressFromBech32(str)
-		s.Require().NoError(err)
-		s.Require().Equal(acc, *res)
+		assert.NoError(t, err)
+		assert.Equal(t, acc, *res)
 
 		str = hex.EncodeToString(acc)
 		*res, err = types.AccAddressFromHexUnsafe(str)
-		s.Require().NoError(err)
-		s.Require().Equal(acc, *res)
-	}
+		assert.NoError(t, err)
+		assert.Equal(t, acc, *res)
+	})
+}
+
+func (s *addressTestSuite) TestUnmarshalYAMLWithInvalidInput() {
 
 	for _, str := range invalidStrs {
 		_, err := types.AccAddressFromHexUnsafe(str)

From 40fed6a56586231395c3a6544ffd07c686fba7d5 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 14 May 2024 07:07:26 +0300
Subject: [PATCH 09/12] fix comments

---
 types/address_fuzz_test.go | 38 ++++++++++++++++++++
 types/address_test.go      | 71 +++++++++++---------------------------
 2 files changed, 58 insertions(+), 51 deletions(-)
 create mode 100644 types/address_fuzz_test.go

diff --git a/types/address_fuzz_test.go b/types/address_fuzz_test.go
new file mode 100644
index 000000000000..49f40788aa07
--- /dev/null
+++ b/types/address_fuzz_test.go
@@ -0,0 +1,38 @@
+package types_test
+
+import (
+	"encoding/hex"
+	"testing"
+	
+	"github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+)
+
+func FuzzBech32AccAddrConsistencyYAML(f *testing.F) {
+	if testing.Short() {
+		f.Skip("running in -short mode")
+	}
+
+	f.Add([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	f.Add([]byte{16, 1, 2, 3, 4, 5, 16, 27, 58, 9, 51, 11, 12, 13, 14, 15, 16, 17, 20, 21})
+	f.Add([]byte{19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0})
+
+	f.Fuzz(func(t *testing.T, input []byte) {
+		acc := types.AccAddress(input)
+		res := &types.AccAddress{}
+
+		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
+		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
+
+		str := acc.String()
+		var err error
+		*res, err = types.AccAddressFromBech32(str)
+		require.NoError(t, err)
+		require.Equal(t, acc, *res)
+
+		str = hex.EncodeToString(acc)
+		*res, err = types.AccAddressFromHexUnsafe(str)
+		require.NoError(t, err)
+		require.Equal(t, acc, *res)
+	})
+}
diff --git a/types/address_test.go b/types/address_test.go
index f5c3c4aafe23..2322ed373a5b 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -5,7 +5,6 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
-	"github.com/stretchr/testify/assert"
 	mathrand "math/rand"
 	"strings"
 	"testing"
@@ -65,9 +64,9 @@ func (s *addressTestSuite) testMarshal(original, res interface{}, marshal func()
 func testMarshalYAML(t *testing.T, original, res interface{}, marshal func() (interface{}, error), unmarshal func([]byte) error) {
 	bz, err := marshal()
 
-	assert.NoError(t, err)
-	assert.NoError(t, unmarshal([]byte(bz.(string))))
-	assert.Equal(t, original, res)
+	require.NoError(t, err)
+	require.NoError(t, unmarshal([]byte(bz.(string))))
+	require.Equal(t, original, res)
 }
 
 func (s *addressTestSuite) TestEmptyAddresses() {
@@ -132,59 +131,30 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 
 	for _, str := range invalidStrs {
 		_, err := types.AccAddressFromHexUnsafe(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		_, err = types.AccAddressFromBech32(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		err = (*types.AccAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\""))
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 	}
 
 	_, err := types.AccAddressFromHexUnsafe("")
 	s.Require().Equal(types.ErrEmptyHexAddress, err)
 }
 
-func FuzzBech32AccAddrConsistencyYAML(f *testing.F) {
-	if testing.Short() {
-		f.Skip("running in -short mode")
-	}
-
-	f.Add([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
-	f.Add([]byte{16, 1, 2, 3, 4, 5, 16, 27, 58, 9, 51, 11, 12, 13, 14, 15, 16, 17, 20, 21})
-	f.Add([]byte{19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0})
-
-	f.Fuzz(func(t *testing.T, input []byte) {
-		acc := types.AccAddress(input)
-		res := &types.AccAddress{}
-
-		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
-		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
-
-		str := acc.String()
-		var err error
-		*res, err = types.AccAddressFromBech32(str)
-		assert.NoError(t, err)
-		assert.Equal(t, acc, *res)
-
-		str = hex.EncodeToString(acc)
-		*res, err = types.AccAddressFromHexUnsafe(str)
-		assert.NoError(t, err)
-		assert.Equal(t, acc, *res)
-	})
-}
-
 func (s *addressTestSuite) TestUnmarshalYAMLWithInvalidInput() {
 
 	for _, str := range invalidStrs {
 		_, err := types.AccAddressFromHexUnsafe(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		_, err = types.AccAddressFromBech32(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		err = (*types.AccAddress)(nil).UnmarshalYAML([]byte("\"" + str + "\""))
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 	}
 
 	_, err := types.AccAddressFromHexUnsafe("")
@@ -289,13 +259,13 @@ func (s *addressTestSuite) TestValAddr() {
 
 	for _, str := range invalidStrs {
 		_, err := types.ValAddressFromHex(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		_, err = types.ValAddressFromBech32(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		err = (*types.ValAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\""))
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 	}
 
 	// test empty string
@@ -329,13 +299,13 @@ func (s *addressTestSuite) TestConsAddress() {
 
 	for _, str := range invalidStrs {
 		_, err := types.ConsAddressFromHex(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		_, err = types.ConsAddressFromBech32(str)
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 
 		err = (*types.ConsAddress)(nil).UnmarshalJSON([]byte("\"" + str + "\""))
-		s.Require().NotNil(err)
+		s.Require().Error(err)
 	}
 
 	// test empty string
@@ -619,9 +589,10 @@ func (s *addressTestSuite) TestGetBech32PrefixConsPub() {
 }
 
 func (s *addressTestSuite) TestMustAccAddressFromBech32() {
-	accAddress1 := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
-	accAddress2 := types.MustAccAddressFromBech32(accAddress1.String())
-	s.Require().Equal(accAddress1, accAddress2)
+	src := types.MustAccAddressFromBech32("cosmos1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnrk363e")
+	exp := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	s.Assert().Equal(exp, src)
+
 }
 
 func (s *addressTestSuite) TestMustAccAddressFromBech32Panic() {
@@ -773,9 +744,7 @@ func (s *addressTestSuite) TestFormatConsAddressAsString() {
 	consAddr := types.ConsAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
 	actual := fmt.Sprintf("%s", consAddr)
 
-	hrp := types.GetConfig().GetBech32ConsensusAddrPrefix()
-	expected, err := bech32.ConvertAndEncode(hrp, consAddr)
-	s.Require().NoError(err)
+	expected := "cosmosvalcons1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnj3kn3t"
 	s.Require().Equal(expected, actual)
 }
 

From 804e64978a65916c943b2f3c000c1614f25ca217 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 14 May 2024 16:18:05 +0300
Subject: [PATCH 10/12] fix golint

---
 fuzz/oss-fuzz-build.sh     | 1 +
 types/address_fuzz_test.go | 3 +--
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fuzz/oss-fuzz-build.sh b/fuzz/oss-fuzz-build.sh
index 882b77f52429..faa7c76b5d7b 100644
--- a/fuzz/oss-fuzz-build.sh
+++ b/fuzz/oss-fuzz-build.sh
@@ -25,6 +25,7 @@ go get github.com/AdamKorcz/go-118-fuzz-build/testing
 # because of the separate query_test package.
 # compile_native_go_fuzzer "$FUZZ_ROOT"/types/query FuzzPagination fuzz_types_query_pagination
 compile_native_go_fuzzer "$FUZZ_ROOT"/types FuzzCoinUnmarshalJSON fuzz_types_coin_unmarshal_json
+compile_native_go_fuzzer "$FUZZ_ROOT"/types FuzzBech32AccAddrConsistencyYAML fuzz_types_bech32_acc_addr_consistency_yaml
 
 build_go_fuzzer FuzzCryptoHDDerivePrivateKeyForPath fuzz_crypto_hd_deriveprivatekeyforpath
 build_go_fuzzer FuzzCryptoHDNewParamsFromPath fuzz_crypto_hd_newparamsfrompath
diff --git a/types/address_fuzz_test.go b/types/address_fuzz_test.go
index 49f40788aa07..4655c4625e9a 100644
--- a/types/address_fuzz_test.go
+++ b/types/address_fuzz_test.go
@@ -3,7 +3,7 @@ package types_test
 import (
 	"encoding/hex"
 	"testing"
-	
+
 	"github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
 )
@@ -21,7 +21,6 @@ func FuzzBech32AccAddrConsistencyYAML(f *testing.F) {
 		acc := types.AccAddress(input)
 		res := &types.AccAddress{}
 
-		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
 		testMarshalYAML(t, &acc, res, acc.MarshalYAML, res.UnmarshalYAML)
 
 		str := acc.String()

From c5abd382fe0e9aea438720ddf7c05e786a507c53 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 14 May 2024 16:41:03 +0300
Subject: [PATCH 11/12] fix failing tests

---
 types/address_test.go | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/types/address_test.go b/types/address_test.go
index 2322ed373a5b..52ea7698a20f 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -62,6 +62,7 @@ func (s *addressTestSuite) testMarshal(original, res interface{}, marshal func()
 }
 
 func testMarshalYAML(t *testing.T, original, res interface{}, marshal func() (interface{}, error), unmarshal func([]byte) error) {
+	t.Helper()
 	bz, err := marshal()
 
 	require.NoError(t, err)
@@ -589,10 +590,9 @@ func (s *addressTestSuite) TestGetBech32PrefixConsPub() {
 }
 
 func (s *addressTestSuite) TestMustAccAddressFromBech32() {
-	src := types.MustAccAddressFromBech32("cosmos1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnrk363e")
-	exp := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
-	s.Assert().Equal(exp, src)
-
+	accAddress1 := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
+	accAddress2 := types.MustAccAddressFromBech32(accAddress1.String())
+	s.Require().Equal(accAddress1, accAddress2)
 }
 
 func (s *addressTestSuite) TestMustAccAddressFromBech32Panic() {
@@ -649,8 +649,8 @@ func (s *addressTestSuite) TestFormatAccAddressAsPointer() {
 }
 
 func (s *addressTestSuite) TestFormatAccAddressWhenVerbIsDifferentFromSOrP() {
-	myAddr := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
-	exp := "000102030405060708090A0B0C0D0E0F10111213"
+	myAddr := types.AccAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20})
+	exp := "000102030405060708090A0B0C0D0E0F10111214"
 	spec := []string{"%v", "%#v", "%t", "%b", "%c", "%d", "%o", "%O", "%x", "%X", "%U", "%e", "%E", "%f", "%F", "%g", "%G"}
 	for _, v := range spec {
 		s.Require().Equal(exp, fmt.Sprintf(v, myAddr), v)
@@ -744,7 +744,9 @@ func (s *addressTestSuite) TestFormatConsAddressAsString() {
 	consAddr := types.ConsAddress([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
 	actual := fmt.Sprintf("%s", consAddr)
 
-	expected := "cosmosvalcons1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnj3kn3t"
+	hrp := types.GetConfig().GetBech32ConsensusAddrPrefix()
+	expected, err := bech32.ConvertAndEncode(hrp, consAddr)
+	s.Require().NoError(err)
 	s.Require().Equal(expected, actual)
 }
 

From d5e53b4303e70d27da7c80bec961fb62b346c1c2 Mon Sep 17 00:00:00 2001
From: Emil Georgiev <emil.georgiev@mail.schwarz>
Date: Tue, 14 May 2024 17:18:15 +0300
Subject: [PATCH 12/12] fix lint

---
 types/address_fuzz_test.go | 3 ++-
 types/address_test.go      | 1 -
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/types/address_fuzz_test.go b/types/address_fuzz_test.go
index 4655c4625e9a..b15f2582db40 100644
--- a/types/address_fuzz_test.go
+++ b/types/address_fuzz_test.go
@@ -4,8 +4,9 @@ import (
 	"encoding/hex"
 	"testing"
 
-	"github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/types"
 )
 
 func FuzzBech32AccAddrConsistencyYAML(f *testing.F) {
diff --git a/types/address_test.go b/types/address_test.go
index 52ea7698a20f..394dc46a423d 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -146,7 +146,6 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 }
 
 func (s *addressTestSuite) TestUnmarshalYAMLWithInvalidInput() {
-
 	for _, str := range invalidStrs {
 		_, err := types.AccAddressFromHexUnsafe(str)
 		s.Require().Error(err)