feat: x/group tests to mocks (#12864)

## Description

Closes: #12763 



---

### Author Checklist

*All items are required. Please add a note to the item if the item is not applicable and
please add links to any relevant follow up issues.*

I have...

- [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] added `!` to the type prefix if API or client breaking change
- [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting))
- [ ] provided a link to the relevant issue or specification
- [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules)
- [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing)
- [ ] added a changelog entry to `CHANGELOG.md`
- [ ] included comments for [documenting Go code](https://blog.golang.org/godoc)
- [ ] updated the relevant documentation or specification
- [ ] reviewed "Files changed" and left comments if necessary
- [ ] confirmed all CI checks have passed

### Reviewers Checklist

*All items are required. Please add a note if the item is not applicable and please add
your handle next to the items reviewed if you only reviewed selected items.*

I have...

- [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] confirmed `!` in the type prefix if API or client breaking change
- [ ] confirmed all author checklist items have been addressed 
- [ ] reviewed state machine logic
- [ ] reviewed API design and naming
- [ ] reviewed documentation is accurate
- [ ] reviewed tests and test coverage
- [ ] manually tested (if applicable)

scripts/mockgen.sh

@@ -19,5 +19,6 @@ $mockgen_cmd -source=x/auth/types/expected_keepers.go -package testutil -destina
 $mockgen_cmd -source=x/auth/ante/expected_keepers.go -package testutil -destination x/auth/ante/testutil/expected_keepers_mocks.go
 $mockgen_cmd -source=x/authz/expected_keepers.go -package testutil -destination x/authz/testutil/expected_keepers_mocks.go
 $mockgen_cmd -source=x/bank/types/expected_keepers.go -package testutil -destination x/bank/testutil/expected_keepers_mocks.go
+$mockgen_cmd -source=x/group/testutil/expected_keepers.go -package testutil -destination x/group/testutil/expected_keepers_mocks.go
 $mockgen_cmd -source=x/evidence/types/expected_keepers.go -package testutil -destination x/evidence/testutil/expected_keepers_mocks.go
 $mockgen_cmd -source=x/slashing/types/expected_keepers.go -package testutil -destination x/slashing/testutil/expected_keepers_mocks.go

store/v2alpha1/dbadapter/store_test.go

@@ -20,7 +20,7 @@ func TestAccessors(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
-	mockDB := mocks.NewMockDBReadWriter(mockCtrl)
+	mockDB := mocks.NewMockReadWriter(mockCtrl)
 	store := dbadapter.Store{mockDB}
 	key := []byte("test")
 	value := []byte("testvalue")
@@ -64,7 +64,7 @@ func TestIterators(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
-	mockDB := mocks.NewMockDBReadWriter(mockCtrl)
+	mockDB := mocks.NewMockReadWriter(mockCtrl)
 	store := dbadapter.Store{mockDB}
 	key := []byte("test")
 	value := []byte("testvalue")
@@ -91,7 +91,7 @@ func TestIterators(t *testing.T) {
 
 func TestCacheWraps(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
-	mockDB := mocks.NewMockDBReadWriter(mockCtrl)
+	mockDB := mocks.NewMockReadWriter(mockCtrl)
 	store := dbadapter.Store{mockDB}
 
 	cacheWrapper := store.CacheWrap()

tests/mocks/db/types.go

@@ -177,31 +177,31 @@ func (mr *MockConnectionMockRecorder) Writer() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Writer", reflect.TypeOf((*MockConnection)(nil).Writer))
 }
 
-// MockDBReader is a mock of DBReader interface.
-type MockDBReader struct {
+// MockReader is a mock of Reader interface.
+type MockReader struct {
 	ctrl     *gomock.Controller
-	recorder *MockDBReaderMockRecorder
+	recorder *MockReaderMockRecorder
 }
 
-// MockDBReaderMockRecorder is the mock recorder for MockDBReader.
-type MockDBReaderMockRecorder struct {
-	mock *MockDBReader
+// MockReaderMockRecorder is the mock recorder for MockReader.
+type MockReaderMockRecorder struct {
+	mock *MockReader
 }
 
-// NewMockDBReader creates a new mock instance.
-func NewMockDBReader(ctrl *gomock.Controller) *MockDBReader {
-	mock := &MockDBReader{ctrl: ctrl}
-	mock.recorder = &MockDBReaderMockRecorder{mock}
+// NewMockReader creates a new mock instance.
+func NewMockReader(ctrl *gomock.Controller) *MockReader {
+	mock := &MockReader{ctrl: ctrl}
+	mock.recorder = &MockReaderMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockDBReader) EXPECT() *MockDBReaderMockRecorder {
+func (m *MockReader) EXPECT() *MockReaderMockRecorder {
 	return m.recorder
 }
 
 // Discard mocks base method.
-func (m *MockDBReader) Discard() error {
+func (m *MockReader) Discard() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Discard")
 	ret0, _ := ret[0].(error)
@@ -209,13 +209,13 @@ func (m *MockDBReader) Discard() error {
 }
 
 // Discard indicates an expected call of Discard.
-func (mr *MockDBReaderMockRecorder) Discard() *gomock.Call {
+func (mr *MockReaderMockRecorder) Discard() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDBReader)(nil).Discard))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockReader)(nil).Discard))
 }
 
 // Get mocks base method.
-func (m *MockDBReader) Get(arg0 []byte) ([]byte, error) {
+func (m *MockReader) Get(arg0 []byte) ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get", arg0)
 	ret0, _ := ret[0].([]byte)
@@ -224,13 +224,13 @@ func (m *MockDBReader) Get(arg0 []byte) ([]byte, error) {
 }
 
 // Get indicates an expected call of Get.
-func (mr *MockDBReaderMockRecorder) Get(arg0 interface{}) *gomock.Call {
+func (mr *MockReaderMockRecorder) Get(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDBReader)(nil).Get), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReader)(nil).Get), arg0)
 }
 
 // Has mocks base method.
-func (m *MockDBReader) Has(key []byte) (bool, error) {
+func (m *MockReader) Has(key []byte) (bool, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Has", key)
 	ret0, _ := ret[0].(bool)
@@ -239,13 +239,13 @@ func (m *MockDBReader) Has(key []byte) (bool, error) {
 }
 
 // Has indicates an expected call of Has.
-func (mr *MockDBReaderMockRecorder) Has(key interface{}) *gomock.Call {
+func (mr *MockReaderMockRecorder) Has(key interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockDBReader)(nil).Has), key)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockReader)(nil).Has), key)
 }
 
 // Iterator mocks base method.
-func (m *MockDBReader) Iterator(start, end []byte) (db.Iterator, error) {
+func (m *MockReader) Iterator(start, end []byte) (db.Iterator, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Iterator", start, end)
 	ret0, _ := ret[0].(db.Iterator)
@@ -254,13 +254,13 @@ func (m *MockDBReader) Iterator(start, end []byte) (db.Iterator, error) {
 }
 
 // Iterator indicates an expected call of Iterator.
-func (mr *MockDBReaderMockRecorder) Iterator(start, end interface{}) *gomock.Call {
+func (mr *MockReaderMockRecorder) Iterator(start, end interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockDBReader)(nil).Iterator), start, end)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockReader)(nil).Iterator), start, end)
 }
 
 // ReverseIterator mocks base method.
-func (m *MockDBReader) ReverseIterator(start, end []byte) (db.Iterator, error) {
+func (m *MockReader) ReverseIterator(start, end []byte) (db.Iterator, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReverseIterator", start, end)
 	ret0, _ := ret[0].(db.Iterator)
@@ -269,36 +269,36 @@ func (m *MockDBReader) ReverseIterator(start, end []byte) (db.Iterator, error) {
 }
 
 // ReverseIterator indicates an expected call of ReverseIterator.
-func (mr *MockDBReaderMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call {
+func (mr *MockReaderMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockDBReader)(nil).ReverseIterator), start, end)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockReader)(nil).ReverseIterator), start, end)
 }
 
-// MockDBWriter is a mock of DBWriter interface.
-type MockDBWriter struct {
+// MockWriter is a mock of Writer interface.
+type MockWriter struct {
 	ctrl     *gomock.Controller
-	recorder *MockDBWriterMockRecorder
+	recorder *MockWriterMockRecorder
 }
 
-// MockDBWriterMockRecorder is the mock recorder for MockDBWriter.
-type MockDBWriterMockRecorder struct {
-	mock *MockDBWriter
+// MockWriterMockRecorder is the mock recorder for MockWriter.
+type MockWriterMockRecorder struct {
+	mock *MockWriter
 }
 
-// NewMockDBWriter creates a new mock instance.
-func NewMockDBWriter(ctrl *gomock.Controller) *MockDBWriter {
-	mock := &MockDBWriter{ctrl: ctrl}
-	mock.recorder = &MockDBWriterMockRecorder{mock}
+// NewMockWriter creates a new mock instance.
+func NewMockWriter(ctrl *gomock.Controller) *MockWriter {
+	mock := &MockWriter{ctrl: ctrl}
+	mock.recorder = &MockWriterMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockDBWriter) EXPECT() *MockDBWriterMockRecorder {
+func (m *MockWriter) EXPECT() *MockWriterMockRecorder {
 	return m.recorder
 }
 
 // Commit mocks base method.
-func (m *MockDBWriter) Commit() error {
+func (m *MockWriter) Commit() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Commit")
 	ret0, _ := ret[0].(error)
@@ -306,13 +306,13 @@ func (m *MockDBWriter) Commit() error {
 }
 
 // Commit indicates an expected call of Commit.
-func (mr *MockDBWriterMockRecorder) Commit() *gomock.Call {
+func (mr *MockWriterMockRecorder) Commit() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockDBWriter)(nil).Commit))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockWriter)(nil).Commit))
 }
 
 // Delete mocks base method.
-func (m *MockDBWriter) Delete(arg0 []byte) error {
+func (m *MockWriter) Delete(arg0 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Delete", arg0)
 	ret0, _ := ret[0].(error)
@@ -320,13 +320,13 @@ func (m *MockDBWriter) Delete(arg0 []byte) error {
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *MockDBWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call {
+func (mr *MockWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDBWriter)(nil).Delete), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWriter)(nil).Delete), arg0)
 }
 
 // Discard mocks base method.
-func (m *MockDBWriter) Discard() error {
+func (m *MockWriter) Discard() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Discard")
 	ret0, _ := ret[0].(error)
@@ -334,13 +334,13 @@ func (m *MockDBWriter) Discard() error {
 }
 
 // Discard indicates an expected call of Discard.
-func (mr *MockDBWriterMockRecorder) Discard() *gomock.Call {
+func (mr *MockWriterMockRecorder) Discard() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDBWriter)(nil).Discard))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockWriter)(nil).Discard))
 }
 
 // Set mocks base method.
-func (m *MockDBWriter) Set(arg0, arg1 []byte) error {
+func (m *MockWriter) Set(arg0, arg1 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Set", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -348,36 +348,36 @@ func (m *MockDBWriter) Set(arg0, arg1 []byte) error {
 }
 
 // Set indicates an expected call of Set.
-func (mr *MockDBWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDBWriter)(nil).Set), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockWriter)(nil).Set), arg0, arg1)
 }
 
-// MockDBReadWriter is a mock of DBReadWriter interface.
-type MockDBReadWriter struct {
+// MockReadWriter is a mock of ReadWriter interface.
+type MockReadWriter struct {
 	ctrl     *gomock.Controller
-	recorder *MockDBReadWriterMockRecorder
+	recorder *MockReadWriterMockRecorder
 }
 
-// MockDBReadWriterMockRecorder is the mock recorder for MockDBReadWriter.
-type MockDBReadWriterMockRecorder struct {
-	mock *MockDBReadWriter
+// MockReadWriterMockRecorder is the mock recorder for MockReadWriter.
+type MockReadWriterMockRecorder struct {
+	mock *MockReadWriter
 }
 
-// NewMockDBReadWriter creates a new mock instance.
-func NewMockDBReadWriter(ctrl *gomock.Controller) *MockDBReadWriter {
-	mock := &MockDBReadWriter{ctrl: ctrl}
-	mock.recorder = &MockDBReadWriterMockRecorder{mock}
+// NewMockReadWriter creates a new mock instance.
+func NewMockReadWriter(ctrl *gomock.Controller) *MockReadWriter {
+	mock := &MockReadWriter{ctrl: ctrl}
+	mock.recorder = &MockReadWriterMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockDBReadWriter) EXPECT() *MockDBReadWriterMockRecorder {
+func (m *MockReadWriter) EXPECT() *MockReadWriterMockRecorder {
 	return m.recorder
 }
 
 // Commit mocks base method.
-func (m *MockDBReadWriter) Commit() error {
+func (m *MockReadWriter) Commit() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Commit")
 	ret0, _ := ret[0].(error)
@@ -385,13 +385,13 @@ func (m *MockDBReadWriter) Commit() error {
 }
 
 // Commit indicates an expected call of Commit.
-func (mr *MockDBReadWriterMockRecorder) Commit() *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Commit() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockDBReadWriter)(nil).Commit))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockReadWriter)(nil).Commit))
 }
 
 // Delete mocks base method.
-func (m *MockDBReadWriter) Delete(arg0 []byte) error {
+func (m *MockReadWriter) Delete(arg0 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Delete", arg0)
 	ret0, _ := ret[0].(error)
@@ -399,13 +399,13 @@ func (m *MockDBReadWriter) Delete(arg0 []byte) error {
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *MockDBReadWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDBReadWriter)(nil).Delete), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockReadWriter)(nil).Delete), arg0)
 }
 
 // Discard mocks base method.
-func (m *MockDBReadWriter) Discard() error {
+func (m *MockReadWriter) Discard() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Discard")
 	ret0, _ := ret[0].(error)
@@ -413,13 +413,13 @@ func (m *MockDBReadWriter) Discard() error {
 }
 
 // Discard indicates an expected call of Discard.
-func (mr *MockDBReadWriterMockRecorder) Discard() *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Discard() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDBReadWriter)(nil).Discard))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockReadWriter)(nil).Discard))
 }
 
 // Get mocks base method.
-func (m *MockDBReadWriter) Get(arg0 []byte) ([]byte, error) {
+func (m *MockReadWriter) Get(arg0 []byte) ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get", arg0)
 	ret0, _ := ret[0].([]byte)
@@ -428,13 +428,13 @@ func (m *MockDBReadWriter) Get(arg0 []byte) ([]byte, error) {
 }
 
 // Get indicates an expected call of Get.
-func (mr *MockDBReadWriterMockRecorder) Get(arg0 interface{}) *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Get(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDBReadWriter)(nil).Get), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReadWriter)(nil).Get), arg0)
 }
 
 // Has mocks base method.
-func (m *MockDBReadWriter) Has(key []byte) (bool, error) {
+func (m *MockReadWriter) Has(key []byte) (bool, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Has", key)
 	ret0, _ := ret[0].(bool)
@@ -443,13 +443,13 @@ func (m *MockDBReadWriter) Has(key []byte) (bool, error) {
 }
 
 // Has indicates an expected call of Has.
-func (mr *MockDBReadWriterMockRecorder) Has(key interface{}) *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Has(key interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockDBReadWriter)(nil).Has), key)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockReadWriter)(nil).Has), key)
 }
 
 // Iterator mocks base method.
-func (m *MockDBReadWriter) Iterator(start, end []byte) (db.Iterator, error) {
+func (m *MockReadWriter) Iterator(start, end []byte) (db.Iterator, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Iterator", start, end)
 	ret0, _ := ret[0].(db.Iterator)
@@ -458,13 +458,13 @@ func (m *MockDBReadWriter) Iterator(start, end []byte) (db.Iterator, error) {
 }
 
 // Iterator indicates an expected call of Iterator.
-func (mr *MockDBReadWriterMockRecorder) Iterator(start, end interface{}) *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Iterator(start, end interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockDBReadWriter)(nil).Iterator), start, end)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockReadWriter)(nil).Iterator), start, end)
 }
 
 // ReverseIterator mocks base method.
-func (m *MockDBReadWriter) ReverseIterator(start, end []byte) (db.Iterator, error) {
+func (m *MockReadWriter) ReverseIterator(start, end []byte) (db.Iterator, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReverseIterator", start, end)
 	ret0, _ := ret[0].(db.Iterator)
@@ -473,13 +473,13 @@ func (m *MockDBReadWriter) ReverseIterator(start, end []byte) (db.Iterator, erro
 }
 
 // ReverseIterator indicates an expected call of ReverseIterator.
-func (mr *MockDBReadWriterMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call {
+func (mr *MockReadWriterMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockDBReadWriter)(nil).ReverseIterator), start, end)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockReadWriter)(nil).ReverseIterator), start, end)
 }
 
 // Set mocks base method.
-func (m *MockDBReadWriter) Set(arg0, arg1 []byte) error {
+func (m *MockReadWriter) Set(arg0, arg1 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Set", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -487,9 +487,9 @@ func (m *MockDBReadWriter) Set(arg0, arg1 []byte) error {
 }
 
 // Set indicates an expected call of Set.
-func (mr *MockDBReadWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockReadWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDBReadWriter)(nil).Set), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockReadWriter)(nil).Set), arg0, arg1)
 }
 
 // MockIterator is a mock of Iterator interface.

tests/mocks/types_module_module.go

@@ -328,18 +328,6 @@ func (m *MockAppModule) EXPECT() *MockAppModuleMockRecorder {
 	return m.recorder
 }
 
-// BeginBlock mocks base method.
-func (m *MockAppModule) BeginBlock(arg0 types0.Context, arg1 types1.RequestBeginBlock) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "BeginBlock", arg0, arg1)
-}
-
-// BeginBlock indicates an expected call of BeginBlock.
-func (mr *MockAppModuleMockRecorder) BeginBlock(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockAppModule)(nil).BeginBlock), arg0, arg1)
-}
-
 // ConsensusVersion mocks base method.
 func (m *MockAppModule) ConsensusVersion() uint64 {
 	m.ctrl.T.Helper()
@@ -368,20 +356,6 @@ func (mr *MockAppModuleMockRecorder) DefaultGenesis(arg0 interface{}) *gomock.Ca
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultGenesis", reflect.TypeOf((*MockAppModule)(nil).DefaultGenesis), arg0)
 }
 
-// EndBlock mocks base method.
-func (m *MockAppModule) EndBlock(arg0 types0.Context, arg1 types1.RequestEndBlock) []types1.ValidatorUpdate {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EndBlock", arg0, arg1)
-	ret0, _ := ret[0].([]types1.ValidatorUpdate)
-	return ret0
-}
-
-// EndBlock indicates an expected call of EndBlock.
-func (mr *MockAppModuleMockRecorder) EndBlock(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndBlock", reflect.TypeOf((*MockAppModule)(nil).EndBlock), arg0, arg1)
-}
-
 // ExportGenesis mocks base method.
 func (m *MockAppModule) ExportGenesis(arg0 types0.Context, arg1 codec.JSONCodec) json.RawMessage {
 	m.ctrl.T.Helper()
@@ -438,20 +412,6 @@ func (mr *MockAppModuleMockRecorder) InitGenesis(arg0, arg1, arg2 interface{}) *
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockAppModule)(nil).InitGenesis), arg0, arg1, arg2)
 }
 
-// LegacyQuerierHandler mocks base method.
-func (m *MockAppModule) LegacyQuerierHandler(arg0 *codec.LegacyAmino) types0.Querier {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LegacyQuerierHandler", arg0)
-	ret0, _ := ret[0].(types0.Querier)
-	return ret0
-}
-
-// LegacyQuerierHandler indicates an expected call of LegacyQuerierHandler.
-func (mr *MockAppModuleMockRecorder) LegacyQuerierHandler(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LegacyQuerierHandler", reflect.TypeOf((*MockAppModule)(nil).LegacyQuerierHandler), arg0)
-}
-
 // Name mocks base method.
 func (m *MockAppModule) Name() string {
 	m.ctrl.T.Helper()
@@ -466,20 +426,6 @@ func (mr *MockAppModuleMockRecorder) Name() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockAppModule)(nil).Name))
 }
 
-// QuerierRoute mocks base method.
-func (m *MockAppModule) QuerierRoute() string {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "QuerierRoute")
-	ret0, _ := ret[0].(string)
-	return ret0
-}
-
-// QuerierRoute indicates an expected call of QuerierRoute.
-func (mr *MockAppModuleMockRecorder) QuerierRoute() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerierRoute", reflect.TypeOf((*MockAppModule)(nil).QuerierRoute))
-}
-
 // RegisterGRPCGatewayRoutes mocks base method.
 func (m *MockAppModule) RegisterGRPCGatewayRoutes(arg0 client.Context, arg1 *runtime.ServeMux) {
 	m.ctrl.T.Helper()
@@ -540,20 +486,6 @@ func (mr *MockAppModuleMockRecorder) RegisterServices(arg0 interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterServices", reflect.TypeOf((*MockAppModule)(nil).RegisterServices), arg0)
 }
 
-// Route mocks base method.
-func (m *MockAppModule) Route() types0.Route {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Route")
-	ret0, _ := ret[0].(types0.Route)
-	return ret0
-}
-
-// Route indicates an expected call of Route.
-func (mr *MockAppModuleMockRecorder) Route() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Route", reflect.TypeOf((*MockAppModule)(nil).Route))
-}
-
 // ValidateGenesis mocks base method.
 func (m *MockAppModule) ValidateGenesis(arg0 codec.JSONCodec, arg1 client.TxEncodingConfig, arg2 json.RawMessage) error {
 	m.ctrl.T.Helper()
@@ -567,3 +499,419 @@ func (mr *MockAppModuleMockRecorder) ValidateGenesis(arg0, arg1, arg2 interface{
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockAppModule)(nil).ValidateGenesis), arg0, arg1, arg2)
 }
+
+// MockBeginBlockAppModule is a mock of BeginBlockAppModule interface.
+type MockBeginBlockAppModule struct {
+	ctrl     *gomock.Controller
+	recorder *MockBeginBlockAppModuleMockRecorder
+}
+
+// MockBeginBlockAppModuleMockRecorder is the mock recorder for MockBeginBlockAppModule.
+type MockBeginBlockAppModuleMockRecorder struct {
+	mock *MockBeginBlockAppModule
+}
+
+// NewMockBeginBlockAppModule creates a new mock instance.
+func NewMockBeginBlockAppModule(ctrl *gomock.Controller) *MockBeginBlockAppModule {
+	mock := &MockBeginBlockAppModule{ctrl: ctrl}
+	mock.recorder = &MockBeginBlockAppModuleMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBeginBlockAppModule) EXPECT() *MockBeginBlockAppModuleMockRecorder {
+	return m.recorder
+}
+
+// BeginBlock mocks base method.
+func (m *MockBeginBlockAppModule) BeginBlock(arg0 types0.Context, arg1 types1.RequestBeginBlock) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "BeginBlock", arg0, arg1)
+}
+
+// BeginBlock indicates an expected call of BeginBlock.
+func (mr *MockBeginBlockAppModuleMockRecorder) BeginBlock(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockBeginBlockAppModule)(nil).BeginBlock), arg0, arg1)
+}
+
+// ConsensusVersion mocks base method.
+func (m *MockBeginBlockAppModule) ConsensusVersion() uint64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConsensusVersion")
+	ret0, _ := ret[0].(uint64)
+	return ret0
+}
+
+// ConsensusVersion indicates an expected call of ConsensusVersion.
+func (mr *MockBeginBlockAppModuleMockRecorder) ConsensusVersion() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusVersion", reflect.TypeOf((*MockBeginBlockAppModule)(nil).ConsensusVersion))
+}
+
+// DefaultGenesis mocks base method.
+func (m *MockBeginBlockAppModule) DefaultGenesis(arg0 codec.JSONCodec) json.RawMessage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DefaultGenesis", arg0)
+	ret0, _ := ret[0].(json.RawMessage)
+	return ret0
+}
+
+// DefaultGenesis indicates an expected call of DefaultGenesis.
+func (mr *MockBeginBlockAppModuleMockRecorder) DefaultGenesis(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).DefaultGenesis), arg0)
+}
+
+// ExportGenesis mocks base method.
+func (m *MockBeginBlockAppModule) ExportGenesis(arg0 types0.Context, arg1 codec.JSONCodec) json.RawMessage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExportGenesis", arg0, arg1)
+	ret0, _ := ret[0].(json.RawMessage)
+	return ret0
+}
+
+// ExportGenesis indicates an expected call of ExportGenesis.
+func (mr *MockBeginBlockAppModuleMockRecorder) ExportGenesis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).ExportGenesis), arg0, arg1)
+}
+
+// GetQueryCmd mocks base method.
+func (m *MockBeginBlockAppModule) GetQueryCmd() *cobra.Command {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetQueryCmd")
+	ret0, _ := ret[0].(*cobra.Command)
+	return ret0
+}
+
+// GetQueryCmd indicates an expected call of GetQueryCmd.
+func (mr *MockBeginBlockAppModuleMockRecorder) GetQueryCmd() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryCmd", reflect.TypeOf((*MockBeginBlockAppModule)(nil).GetQueryCmd))
+}
+
+// GetTxCmd mocks base method.
+func (m *MockBeginBlockAppModule) GetTxCmd() *cobra.Command {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTxCmd")
+	ret0, _ := ret[0].(*cobra.Command)
+	return ret0
+}
+
+// GetTxCmd indicates an expected call of GetTxCmd.
+func (mr *MockBeginBlockAppModuleMockRecorder) GetTxCmd() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxCmd", reflect.TypeOf((*MockBeginBlockAppModule)(nil).GetTxCmd))
+}
+
+// InitGenesis mocks base method.
+func (m *MockBeginBlockAppModule) InitGenesis(arg0 types0.Context, arg1 codec.JSONCodec, arg2 json.RawMessage) []types1.ValidatorUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InitGenesis", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]types1.ValidatorUpdate)
+	return ret0
+}
+
+// InitGenesis indicates an expected call of InitGenesis.
+func (mr *MockBeginBlockAppModuleMockRecorder) InitGenesis(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).InitGenesis), arg0, arg1, arg2)
+}
+
+// Name mocks base method.
+func (m *MockBeginBlockAppModule) Name() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Name")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Name indicates an expected call of Name.
+func (mr *MockBeginBlockAppModuleMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockBeginBlockAppModule)(nil).Name))
+}
+
+// RegisterGRPCGatewayRoutes mocks base method.
+func (m *MockBeginBlockAppModule) RegisterGRPCGatewayRoutes(arg0 client.Context, arg1 *runtime.ServeMux) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterGRPCGatewayRoutes", arg0, arg1)
+}
+
+// RegisterGRPCGatewayRoutes indicates an expected call of RegisterGRPCGatewayRoutes.
+func (mr *MockBeginBlockAppModuleMockRecorder) RegisterGRPCGatewayRoutes(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGRPCGatewayRoutes", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterGRPCGatewayRoutes), arg0, arg1)
+}
+
+// RegisterInterfaces mocks base method.
+func (m *MockBeginBlockAppModule) RegisterInterfaces(arg0 types.InterfaceRegistry) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterInterfaces", arg0)
+}
+
+// RegisterInterfaces indicates an expected call of RegisterInterfaces.
+func (mr *MockBeginBlockAppModuleMockRecorder) RegisterInterfaces(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInterfaces", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterInterfaces), arg0)
+}
+
+// RegisterInvariants mocks base method.
+func (m *MockBeginBlockAppModule) RegisterInvariants(arg0 types0.InvariantRegistry) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterInvariants", arg0)
+}
+
+// RegisterInvariants indicates an expected call of RegisterInvariants.
+func (mr *MockBeginBlockAppModuleMockRecorder) RegisterInvariants(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInvariants", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterInvariants), arg0)
+}
+
+// RegisterLegacyAminoCodec mocks base method.
+func (m *MockBeginBlockAppModule) RegisterLegacyAminoCodec(arg0 *codec.LegacyAmino) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterLegacyAminoCodec", arg0)
+}
+
+// RegisterLegacyAminoCodec indicates an expected call of RegisterLegacyAminoCodec.
+func (mr *MockBeginBlockAppModuleMockRecorder) RegisterLegacyAminoCodec(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterLegacyAminoCodec", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterLegacyAminoCodec), arg0)
+}
+
+// RegisterServices mocks base method.
+func (m *MockBeginBlockAppModule) RegisterServices(arg0 module.Configurator) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterServices", arg0)
+}
+
+// RegisterServices indicates an expected call of RegisterServices.
+func (mr *MockBeginBlockAppModuleMockRecorder) RegisterServices(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterServices", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterServices), arg0)
+}
+
+// ValidateGenesis mocks base method.
+func (m *MockBeginBlockAppModule) ValidateGenesis(arg0 codec.JSONCodec, arg1 client.TxEncodingConfig, arg2 json.RawMessage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ValidateGenesis", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ValidateGenesis indicates an expected call of ValidateGenesis.
+func (mr *MockBeginBlockAppModuleMockRecorder) ValidateGenesis(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).ValidateGenesis), arg0, arg1, arg2)
+}
+
+// MockEndBlockAppModule is a mock of EndBlockAppModule interface.
+type MockEndBlockAppModule struct {
+	ctrl     *gomock.Controller
+	recorder *MockEndBlockAppModuleMockRecorder
+}
+
+// MockEndBlockAppModuleMockRecorder is the mock recorder for MockEndBlockAppModule.
+type MockEndBlockAppModuleMockRecorder struct {
+	mock *MockEndBlockAppModule
+}
+
+// NewMockEndBlockAppModule creates a new mock instance.
+func NewMockEndBlockAppModule(ctrl *gomock.Controller) *MockEndBlockAppModule {
+	mock := &MockEndBlockAppModule{ctrl: ctrl}
+	mock.recorder = &MockEndBlockAppModuleMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockEndBlockAppModule) EXPECT() *MockEndBlockAppModuleMockRecorder {
+	return m.recorder
+}
+
+// ConsensusVersion mocks base method.
+func (m *MockEndBlockAppModule) ConsensusVersion() uint64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConsensusVersion")
+	ret0, _ := ret[0].(uint64)
+	return ret0
+}
+
+// ConsensusVersion indicates an expected call of ConsensusVersion.
+func (mr *MockEndBlockAppModuleMockRecorder) ConsensusVersion() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusVersion", reflect.TypeOf((*MockEndBlockAppModule)(nil).ConsensusVersion))
+}
+
+// DefaultGenesis mocks base method.
+func (m *MockEndBlockAppModule) DefaultGenesis(arg0 codec.JSONCodec) json.RawMessage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DefaultGenesis", arg0)
+	ret0, _ := ret[0].(json.RawMessage)
+	return ret0
+}
+
+// DefaultGenesis indicates an expected call of DefaultGenesis.
+func (mr *MockEndBlockAppModuleMockRecorder) DefaultGenesis(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).DefaultGenesis), arg0)
+}
+
+// EndBlock mocks base method.
+func (m *MockEndBlockAppModule) EndBlock(arg0 types0.Context, arg1 types1.RequestEndBlock) []types1.ValidatorUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EndBlock", arg0, arg1)
+	ret0, _ := ret[0].([]types1.ValidatorUpdate)
+	return ret0
+}
+
+// EndBlock indicates an expected call of EndBlock.
+func (mr *MockEndBlockAppModuleMockRecorder) EndBlock(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndBlock", reflect.TypeOf((*MockEndBlockAppModule)(nil).EndBlock), arg0, arg1)
+}
+
+// ExportGenesis mocks base method.
+func (m *MockEndBlockAppModule) ExportGenesis(arg0 types0.Context, arg1 codec.JSONCodec) json.RawMessage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExportGenesis", arg0, arg1)
+	ret0, _ := ret[0].(json.RawMessage)
+	return ret0
+}
+
+// ExportGenesis indicates an expected call of ExportGenesis.
+func (mr *MockEndBlockAppModuleMockRecorder) ExportGenesis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).ExportGenesis), arg0, arg1)
+}
+
+// GetQueryCmd mocks base method.
+func (m *MockEndBlockAppModule) GetQueryCmd() *cobra.Command {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetQueryCmd")
+	ret0, _ := ret[0].(*cobra.Command)
+	return ret0
+}
+
+// GetQueryCmd indicates an expected call of GetQueryCmd.
+func (mr *MockEndBlockAppModuleMockRecorder) GetQueryCmd() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryCmd", reflect.TypeOf((*MockEndBlockAppModule)(nil).GetQueryCmd))
+}
+
+// GetTxCmd mocks base method.
+func (m *MockEndBlockAppModule) GetTxCmd() *cobra.Command {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTxCmd")
+	ret0, _ := ret[0].(*cobra.Command)
+	return ret0
+}
+
+// GetTxCmd indicates an expected call of GetTxCmd.
+func (mr *MockEndBlockAppModuleMockRecorder) GetTxCmd() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxCmd", reflect.TypeOf((*MockEndBlockAppModule)(nil).GetTxCmd))
+}
+
+// InitGenesis mocks base method.
+func (m *MockEndBlockAppModule) InitGenesis(arg0 types0.Context, arg1 codec.JSONCodec, arg2 json.RawMessage) []types1.ValidatorUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InitGenesis", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]types1.ValidatorUpdate)
+	return ret0
+}
+
+// InitGenesis indicates an expected call of InitGenesis.
+func (mr *MockEndBlockAppModuleMockRecorder) InitGenesis(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).InitGenesis), arg0, arg1, arg2)
+}
+
+// Name mocks base method.
+func (m *MockEndBlockAppModule) Name() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Name")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Name indicates an expected call of Name.
+func (mr *MockEndBlockAppModuleMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockEndBlockAppModule)(nil).Name))
+}
+
+// RegisterGRPCGatewayRoutes mocks base method.
+func (m *MockEndBlockAppModule) RegisterGRPCGatewayRoutes(arg0 client.Context, arg1 *runtime.ServeMux) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterGRPCGatewayRoutes", arg0, arg1)
+}
+
+// RegisterGRPCGatewayRoutes indicates an expected call of RegisterGRPCGatewayRoutes.
+func (mr *MockEndBlockAppModuleMockRecorder) RegisterGRPCGatewayRoutes(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGRPCGatewayRoutes", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterGRPCGatewayRoutes), arg0, arg1)
+}
+
+// RegisterInterfaces mocks base method.
+func (m *MockEndBlockAppModule) RegisterInterfaces(arg0 types.InterfaceRegistry) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterInterfaces", arg0)
+}
+
+// RegisterInterfaces indicates an expected call of RegisterInterfaces.
+func (mr *MockEndBlockAppModuleMockRecorder) RegisterInterfaces(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInterfaces", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterInterfaces), arg0)
+}
+
+// RegisterInvariants mocks base method.
+func (m *MockEndBlockAppModule) RegisterInvariants(arg0 types0.InvariantRegistry) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterInvariants", arg0)
+}
+
+// RegisterInvariants indicates an expected call of RegisterInvariants.
+func (mr *MockEndBlockAppModuleMockRecorder) RegisterInvariants(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInvariants", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterInvariants), arg0)
+}
+
+// RegisterLegacyAminoCodec mocks base method.
+func (m *MockEndBlockAppModule) RegisterLegacyAminoCodec(arg0 *codec.LegacyAmino) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterLegacyAminoCodec", arg0)
+}
+
+// RegisterLegacyAminoCodec indicates an expected call of RegisterLegacyAminoCodec.
+func (mr *MockEndBlockAppModuleMockRecorder) RegisterLegacyAminoCodec(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterLegacyAminoCodec", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterLegacyAminoCodec), arg0)
+}
+
+// RegisterServices mocks base method.
+func (m *MockEndBlockAppModule) RegisterServices(arg0 module.Configurator) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterServices", arg0)
+}
+
+// RegisterServices indicates an expected call of RegisterServices.
+func (mr *MockEndBlockAppModuleMockRecorder) RegisterServices(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterServices", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterServices), arg0)
+}
+
+// ValidateGenesis mocks base method.
+func (m *MockEndBlockAppModule) ValidateGenesis(arg0 codec.JSONCodec, arg1 client.TxEncodingConfig, arg2 json.RawMessage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ValidateGenesis", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ValidateGenesis indicates an expected call of ValidateGenesis.
+func (mr *MockEndBlockAppModuleMockRecorder) ValidateGenesis(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).ValidateGenesis), arg0, arg1, arg2)
+}

testutil/sims/address_helpers.go

@@ -59,7 +59,7 @@ func initAccountWithCoins(bankKeeper bankkeeper.Keeper, ctx sdk.Context, addr sd
 	}
 }
 
-// createIncrementalAccounts is a strategy used by addTestAddrs() in order to generated addresses in ascending order.
+// CreateIncrementalAccounts is a strategy used by addTestAddrs() in order to generated addresses in ascending order.
 func CreateIncrementalAccounts(accNum int) []sdk.AccAddress {
 	var addresses []sdk.AccAddress
 	var buffer bytes.Buffer

types/module/module_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 
-	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/tests/mocks"
@@ -29,8 +28,6 @@ func TestBasicManager(t *testing.T) {
 	interfaceRegistry := types.NewInterfaceRegistry()
 	cdc := codec.NewProtoCodec(interfaceRegistry)
 
-	clientCtx := client.Context{}
-	clientCtx = clientCtx.WithLegacyAmino(legacyAmino)
 	wantDefaultGenesis := map[string]json.RawMessage{"mockAppModuleBasic1": json.RawMessage(``)}
 
 	mockAppModuleBasic1 := mocks.NewMockAppModuleBasic(mockCtrl)
@@ -208,8 +205,8 @@ func TestManager_BeginBlock(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 
-	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
-	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
+	mockAppModule1 := mocks.NewMockBeginBlockAppModule(mockCtrl)
+	mockAppModule2 := mocks.NewMockBeginBlockAppModule(mockCtrl)
 	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
 	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
 	mm := module.NewManager(mockAppModule1, mockAppModule2)
@@ -227,8 +224,8 @@ func TestManager_EndBlock(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 
-	mockAppModule1 := mocks.NewMockAppModule(mockCtrl)
-	mockAppModule2 := mocks.NewMockAppModule(mockCtrl)
+	mockAppModule1 := mocks.NewMockEndBlockAppModule(mockCtrl)
+	mockAppModule2 := mocks.NewMockEndBlockAppModule(mockCtrl)
 	mockAppModule1.EXPECT().Name().Times(2).Return("module1")
 	mockAppModule2.EXPECT().Name().Times(2).Return("module2")
 	mm := module.NewManager(mockAppModule1, mockAppModule2)

x/gov/migrations/v3/store_test.go

@@ -10,7 +10,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
 	"github.com/cosmos/cosmos-sdk/x/gov"
-	v1gov "github.com/cosmos/cosmos-sdk/x/gov/migrations/v1"
+	v1gov "github.com/cosmos/cosmos-sdk/x/gov/migrations/v1" 
 	v3gov "github.com/cosmos/cosmos-sdk/x/gov/migrations/v3"
 	v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
 	"github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"

x/group/keeper/genesis_test.go

@@ -6,31 +6,32 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/suite"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/libs/log"
 
+	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
+	"github.com/cosmos/cosmos-sdk/testutil"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	"github.com/cosmos/cosmos-sdk/x/group"
 	"github.com/cosmos/cosmos-sdk/x/group/keeper"
-	"github.com/cosmos/cosmos-sdk/x/group/testutil"
+	"github.com/cosmos/cosmos-sdk/x/group/module"
+	grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
 )
 
 type GenesisTestSuite struct {
 	suite.Suite
 
-	app               *runtime.App
-	ctx               context.Context
-	sdkCtx            sdk.Context
-	keeper            keeper.Keeper
-	cdc               *codec.ProtoCodec
-	interfaceRegistry codectypes.InterfaceRegistry
+	ctx    context.Context
+	sdkCtx sdk.Context
+	keeper keeper.Keeper
+	cdc    *codec.ProtoCodec
 }
 
 func TestGenesisTestSuite(t *testing.T) {
@@ -44,18 +45,30 @@ var (
 	memberAddr = sdk.AccAddress(memberPub.Address())
 )
 
-func (s *GenesisTestSuite) SetupSuite() {
-	app, err := simtestutil.SetupAtGenesis(
-		testutil.AppConfig,
-		&s.interfaceRegistry,
-		&s.keeper,
-	)
-	s.Require().NoError(err)
+func (s *GenesisTestSuite) SetupTest() {
+	key := sdk.NewKVStoreKey(group.StoreKey)
+	testCtx := testutil.DefaultContextWithDB(s.T(), key, sdk.NewTransientStoreKey("transient_test"))
+	encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{})
 
-	s.app = app
-	s.sdkCtx = app.BaseApp.NewUncachedContext(false, tmproto.Header{})
-	s.cdc = codec.NewProtoCodec(s.interfaceRegistry)
+	ctrl := gomock.NewController(s.T())
+	accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl)
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), accAddr).Return(authtypes.NewBaseAccountWithAddress(accAddr)).AnyTimes()
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), memberAddr).Return(authtypes.NewBaseAccountWithAddress(memberAddr)).AnyTimes()
+
+	bApp := baseapp.NewBaseApp(
+		"group",
+		log.NewNopLogger(),
+		testCtx.DB,
+		encCfg.TxConfig.TxDecoder(),
+	)
+
+	banktypes.RegisterInterfaces(encCfg.InterfaceRegistry)
+
+	s.sdkCtx = testCtx.Ctx
+	s.cdc = codec.NewProtoCodec(encCfg.InterfaceRegistry)
 	s.ctx = sdk.WrapSDKContext(s.sdkCtx)
+
+	s.keeper = keeper.NewKeeper(key, s.cdc, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
 }
 
 func (s *GenesisTestSuite) TestInitExportGenesis() {

x/group/keeper/grpc_query_test.go

@@ -8,45 +8,63 @@ import (
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	"github.com/cosmos/cosmos-sdk/x/group"
 	groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper"
-	"github.com/cosmos/cosmos-sdk/x/group/testutil"
-	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	"github.com/cosmos/cosmos-sdk/x/group/module"
+	"github.com/golang/mock/gomock"
+	"github.com/tendermint/tendermint/libs/log"
+
+	grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
+
 	"github.com/stretchr/testify/require"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+	"github.com/cosmos/cosmos-sdk/testutil"
 )
 
 func TestQueryGroupsByMember(t *testing.T) {
 	var (
-		bankKeeper        bankkeeper.Keeper
 		groupKeeper       groupkeeper.Keeper
-		stakingKeeper     *stakingkeeper.Keeper
 		interfaceRegistry codectypes.InterfaceRegistry
 	)
-	app, err := simtestutil.Setup(
-		testutil.AppConfig,
-		&interfaceRegistry,
-		&bankKeeper,
-		&groupKeeper,
-		&stakingKeeper,
-	)
-	require.NoError(t, err)
 
-	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry)
-	group.RegisterQueryServer(queryHelper, groupKeeper)
-	queryClient := group.NewQueryClient(queryHelper)
+	key := sdk.NewKVStoreKey(group.StoreKey)
+	testCtx := testutil.DefaultContextWithDB(t, key, sdk.NewTransientStoreKey("transient_test"))
+	encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{})
+
+	ctx := testCtx.Ctx
+
 	sdkCtx := sdk.WrapSDKContext(ctx)
 
-	addrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 6, sdk.NewInt(30000000))
+	bApp := baseapp.NewBaseApp(
+		"group",
+		log.NewNopLogger(),
+		testCtx.DB,
+		encCfg.TxConfig.TxDecoder(),
+	)
+
+	banktypes.RegisterInterfaces(encCfg.InterfaceRegistry)
+
+	addrs := simtestutil.CreateIncrementalAccounts(6)
+	ctrl := gomock.NewController(t)
+	accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl)
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[0]).Return(authtypes.NewBaseAccountWithAddress(addrs[0])).AnyTimes()
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[1]).Return(authtypes.NewBaseAccountWithAddress(addrs[1])).AnyTimes()
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[2]).Return(authtypes.NewBaseAccountWithAddress(addrs[2])).AnyTimes()
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[3]).Return(authtypes.NewBaseAccountWithAddress(addrs[3])).AnyTimes()
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[4]).Return(authtypes.NewBaseAccountWithAddress(addrs[4])).AnyTimes()
+	accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[5]).Return(authtypes.NewBaseAccountWithAddress(addrs[5])).AnyTimes()
+
+	groupKeeper = groupkeeper.NewKeeper(key, encCfg.Codec, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
 
 	// Initial group, group policy and balance setup
 	members := []group.MemberRequest{
 		{Address: addrs[2].String(), Weight: "1"}, {Address: addrs[3].String(), Weight: "2"},
 	}
 
-	_, err = groupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{
+	_, err := groupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{
 		Admin:   addrs[0].String(),
 		Members: members,
 	})
@@ -61,6 +79,10 @@ func TestQueryGroupsByMember(t *testing.T) {
 	})
 	require.NoError(t, err)
 
+	queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry)
+	group.RegisterQueryServer(queryHelper, groupKeeper)
+	queryClient := group.NewQueryClient(queryHelper)
+
 	// not part of any group
 	resp, err := queryClient.GroupsByMember(context.Background(), &group.QueryGroupsByMemberRequest{
 		Address: addrs[5].String(),

x/group/keeper/keeper.go

@@ -223,6 +223,11 @@ func (k Keeper) GetGroupSequence(ctx sdk.Context) uint64 {
 	return k.groupTable.Sequence().CurVal(ctx.KVStore(k.key))
 }
 
+// GetGroupPolicySeq returns the current value of the group policy table sequence
+func (k Keeper) GetGroupPolicySeq(ctx sdk.Context) uint64 {
+	return k.groupPolicySeq.CurVal(ctx.KVStore(k.key))
+}
+
 // proposalsByVPEnd returns all proposals whose voting_period_end is after the `endTime` time argument.
 func (k Keeper) proposalsByVPEnd(ctx sdk.Context, endTime time.Time) (proposals []group.Proposal, err error) {
 	timeBytes := sdk.FormatTimeBytes(endTime)

x/group/keeper/keeper_test.go

@@ -3,71 +3,91 @@ package keeper_test
 import (
 	"bytes"
 	"context"
+	"encoding/binary"
+	"fmt"
 	"sort"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/suite"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/libs/log"
 	tmtime "github.com/tendermint/tendermint/types/time"
 
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/runtime"
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/testutil"
 	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
-	"github.com/cosmos/cosmos-sdk/x/bank/testutil"
+	"github.com/cosmos/cosmos-sdk/types/address"
+	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/cosmos/cosmos-sdk/x/bank"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	"github.com/cosmos/cosmos-sdk/x/group"
 	"github.com/cosmos/cosmos-sdk/x/group/internal/math"
 	"github.com/cosmos/cosmos-sdk/x/group/keeper"
 	"github.com/cosmos/cosmos-sdk/x/group/module"
 	grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
-	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
 )
 
 type TestSuite struct {
 	suite.Suite
 
-	app               *runtime.App
-	sdkCtx            sdk.Context
-	ctx               context.Context
-	addrs             []sdk.AccAddress
-	groupID           uint64
-	groupPolicyAddr   sdk.AccAddress
-	policy            group.DecisionPolicy
-	groupKeeper       keeper.Keeper
-	blockTime         time.Time
-	bankKeeper        bankkeeper.Keeper
-	stakingKeeper     *stakingkeeper.Keeper
-	interfaceRegistry codectypes.InterfaceRegistry
+	sdkCtx          sdk.Context
+	ctx             context.Context
+	addrs           []sdk.AccAddress
+	groupID         uint64
+	groupPolicyAddr sdk.AccAddress
+	policy          group.DecisionPolicy
+	groupKeeper     keeper.Keeper
+	blockTime       time.Time
+	bankKeeper      *grouptestutil.MockBankKeeper
+	accountKeeper   *grouptestutil.MockAccountKeeper
 }
 
 func (s *TestSuite) SetupTest() {
-	app, err := simtestutil.Setup(
-		grouptestutil.AppConfig,
-		&s.interfaceRegistry,
-		&s.bankKeeper,
-		&s.stakingKeeper,
-		&s.groupKeeper,
-	)
-	s.Require().NoError(err)
-	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-
 	s.blockTime = tmtime.Now()
-	ctx = ctx.WithBlockHeader(tmproto.Header{Time: s.blockTime})
+	key := sdk.NewKVStoreKey(group.StoreKey)
 
-	s.app = app
-	s.sdkCtx = ctx
-	s.ctx = sdk.WrapSDKContext(ctx)
-	s.addrs = simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, ctx, 6, sdk.NewInt(30000000))
+	testCtx := testutil.DefaultContextWithDB(s.T(), key, sdk.NewTransientStoreKey("transient_test"))
+	encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{}, bank.AppModuleBasic{})
+	s.addrs = simtestutil.CreateIncrementalAccounts(6)
+
+	// setup gomock and initialize some globally expected executions
+	ctrl := gomock.NewController(s.T())
+	s.accountKeeper = grouptestutil.NewMockAccountKeeper(ctrl)
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[0]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[0])).AnyTimes()
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[1]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[1])).AnyTimes()
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[2]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[2])).AnyTimes()
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[3]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[3])).AnyTimes()
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[4]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[4])).AnyTimes()
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[5]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[5])).AnyTimes()
+	s.bankKeeper = grouptestutil.NewMockBankKeeper(ctrl)
+
+	bApp := baseapp.NewBaseApp(
+		"group",
+		log.NewNopLogger(),
+		testCtx.DB,
+		encCfg.TxConfig.TxDecoder(),
+	)
+	bApp.SetInterfaceRegistry(encCfg.InterfaceRegistry)
+	banktypes.RegisterMsgServer(bApp.MsgServiceRouter(), s.bankKeeper)
+
+	config := group.DefaultConfig()
+	s.groupKeeper = keeper.NewKeeper(key, encCfg.Codec, bApp.MsgServiceRouter(), s.accountKeeper, config)
+	s.ctx = testCtx.Ctx.WithBlockTime(s.blockTime)
+	s.sdkCtx = sdk.UnwrapSDKContext(s.ctx)
 
 	// Initial group, group policy and balance setup
 	members := []group.MemberRequest{
 		{Address: s.addrs[4].String(), Weight: "1"}, {Address: s.addrs[1].String(), Weight: "2"},
 	}
+
+	s.setNextAccount()
+
 	groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
 		Admin:   s.addrs[0].String(),
 		Members: members,
@@ -86,13 +106,42 @@ func (s *TestSuite) SetupTest() {
 	}
 	err = policyReq.SetDecisionPolicy(policy)
 	s.Require().NoError(err)
+	s.setNextAccount()
+
 	policyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
 	s.Require().NoError(err)
 	s.policy = policy
 	addr, err := sdk.AccAddressFromBech32(policyRes.Address)
 	s.Require().NoError(err)
 	s.groupPolicyAddr = addr
-	s.Require().NoError(testutil.FundAccount(s.bankKeeper, s.sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
+
+	s.bankKeeper.EXPECT().MintCoins(s.sdkCtx, minttypes.ModuleName, sdk.Coins{sdk.NewInt64Coin("test", 100000)}).Return(nil).AnyTimes()
+	s.bankKeeper.MintCoins(s.sdkCtx, minttypes.ModuleName, sdk.Coins{sdk.NewInt64Coin("test", 100000)})
+	s.bankKeeper.EXPECT().SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}).Return(nil).AnyTimes()
+	s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)})
+}
+
+func (s TestSuite) setNextAccount() {
+	nextAccVal := s.groupKeeper.GetGroupPolicySeq(s.sdkCtx) + 1
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, nextAccVal)
+
+	var accountAddr sdk.AccAddress
+	parentAcc := address.Module(group.ModuleName, []byte{keeper.GroupPolicyTablePrefix})
+	accountAddr = address.Derive(parentAcc, buf)
+	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), accountAddr).Return(nil).AnyTimes()
+	s.accountKeeper.EXPECT().NewAccount(gomock.Any(), &authtypes.ModuleAccount{
+		BaseAccount: &authtypes.BaseAccount{
+			Address: accountAddr.String(),
+		},
+		Name: accountAddr.String(),
+	}).Return(authtypes.NewModuleAccount(authtypes.NewBaseAccountWithAddress(accountAddr), accountAddr.String())).AnyTimes()
+	s.accountKeeper.EXPECT().SetAccount(gomock.Any(), &authtypes.ModuleAccount{
+		BaseAccount: &authtypes.BaseAccount{
+			Address: accountAddr.String(),
+		},
+		Name: accountAddr.String(),
+	}).Return().AnyTimes()
 }
 
 func TestKeeperTestSuite(t *testing.T) {
@@ -107,7 +156,7 @@ func (s *TestSuite) TestCreateGroupWithLotsOfMembers() {
 }
 
 func (s *TestSuite) createGroupAndGetMembers(numMembers int) []*group.GroupMember {
-	addressPool := simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, s.sdkCtx, numMembers, sdk.NewInt(30000000))
+	addressPool := simtestutil.CreateIncrementalAccounts(numMembers)
 	members := make([]group.MemberRequest, numMembers)
 	for i := 0; i < len(members); i++ {
 		members[i] = group.MemberRequest{
@@ -722,6 +771,8 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
 	addr5 := addrs[4]
 	addr6 := addrs[5]
 
+	s.setNextAccount()
+
 	members := []group.MemberRequest{{
 		Address: addr5.String(),
 		Weight:  "1",
@@ -733,6 +784,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
 	specs := map[string]struct {
 		req       *group.MsgCreateGroupWithPolicy
 		policy    group.DecisionPolicy
+		malleate  func()
 		expErr    bool
 		expErrMsg string
 	}{
@@ -742,6 +794,9 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
 				Members:            members,
 				GroupPolicyAsAdmin: false,
 			},
+			malleate: func() {
+				s.setNextAccount()
+			},
 			policy: group.NewThresholdDecisionPolicy(
 				"1",
 				time.Second,
@@ -754,6 +809,9 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
 				Members:            members,
 				GroupPolicyAsAdmin: true,
 			},
+			malleate: func() {
+				s.setNextAccount()
+			},
 			policy: group.NewThresholdDecisionPolicy(
 				"1",
 				time.Second,
@@ -831,6 +889,9 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
 				Members:            members,
 				GroupPolicyAsAdmin: false,
 			},
+			malleate: func() {
+				s.setNextAccount()
+			},
 			policy: group.NewThresholdDecisionPolicy(
 				"10",
 				time.Second,
@@ -843,6 +904,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() {
 	for msg, spec := range specs {
 		spec := spec
 		s.Run(msg, func() {
+			s.setNextAccount()
 			err := spec.req.SetDecisionPolicy(spec.policy)
 			s.Require().NoError(err)
 
@@ -916,6 +978,7 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 	addr1 := addrs[0]
 	addr4 := addrs[3]
 
+	s.setNextAccount()
 	groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
 		Admin:   addr1.String(),
 		Members: nil,
@@ -1035,6 +1098,8 @@ func (s *TestSuite) TestCreateGroupPolicy() {
 			err := spec.req.SetDecisionPolicy(spec.policy)
 			s.Require().NoError(err)
 
+			s.setNextAccount()
+
 			res, err := s.groupKeeper.CreateGroupPolicy(s.ctx, spec.req)
 			if spec.expErr {
 				s.Require().Error(err)
@@ -1080,6 +1145,7 @@ func (s *TestSuite) TestUpdateGroupPolicyAdmin() {
 		time.Second,
 		0,
 	)
+	s.setNextAccount()
 	groupPolicyAddr, myGroupID := s.createGroupAndGroupPolicy(admin, nil, policy)
 
 	specs := map[string]struct {
@@ -1168,6 +1234,8 @@ func (s *TestSuite) TestUpdateGroupPolicyMetadata() {
 		time.Second,
 		0,
 	)
+
+	s.setNextAccount()
 	groupPolicyAddr, myGroupID := s.createGroupAndGroupPolicy(admin, nil, policy)
 
 	specs := map[string]struct {
@@ -1247,6 +1315,8 @@ func (s *TestSuite) TestUpdateGroupPolicyDecisionPolicy() {
 		time.Second,
 		0,
 	)
+
+	s.setNextAccount()
 	groupPolicyAddr, myGroupID := s.createGroupAndGroupPolicy(admin, nil, policy)
 
 	specs := map[string]struct {
@@ -1296,6 +1366,7 @@ func (s *TestSuite) TestUpdateGroupPolicyDecisionPolicy() {
 		},
 		"correct data with percentage decision policy": {
 			preRun: func(admin sdk.AccAddress) (string, uint64) {
+				s.setNextAccount()
 				return s.createGroupAndGroupPolicy(admin, nil, policy)
 			},
 			req: &group.MsgUpdateGroupPolicyDecisionPolicy{
@@ -1357,6 +1428,7 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
 	addr2 := addrs[1]
 
 	admin := addr2
+
 	groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
 		Admin:   admin.String(),
 		Members: nil,
@@ -1391,6 +1463,8 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() {
 		}
 		err := req.SetDecisionPolicy(policies[i])
 		s.Require().NoError(err)
+
+		s.setNextAccount()
 		res, err := s.groupKeeper.CreateGroupPolicy(s.ctx, req)
 		s.Require().NoError(err)
 
@@ -1481,6 +1555,8 @@ func (s *TestSuite) TestSubmitProposal() {
 	)
 	err := policyReq.SetDecisionPolicy(policy)
 	s.Require().NoError(err)
+
+	s.setNextAccount()
 	bigThresholdRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
 	s.Require().NoError(err)
 	bigThresholdAddr := bigThresholdRes.Address
@@ -1502,6 +1578,7 @@ func (s *TestSuite) TestSubmitProposal() {
 		expProposal group.Proposal
 		expErr      bool
 		postRun     func(sdkCtx sdk.Context)
+		preRun      func(msg []sdk.Msg)
 	}{
 		"all good with minimal fields set": {
 			req: &group.MsgSubmitProposal{
@@ -1596,6 +1673,11 @@ func (s *TestSuite) TestSubmitProposal() {
 			postRun: func(sdkCtx sdk.Context) {},
 		},
 		"with try exec": {
+			preRun: func(msgs []sdk.Msg) {
+				for i := 0; i < len(msgs); i++ {
+					s.bankKeeper.EXPECT().Send(gomock.Any(), msgs[i]).Return(nil, nil)
+				}
+			},
 			req: &group.MsgSubmitProposal{
 				GroupPolicyAddress: accountAddr.String(),
 				Proposers:          []string{addr2.String()},
@@ -1614,6 +1696,9 @@ func (s *TestSuite) TestSubmitProposal() {
 				ExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_SUCCESS,
 			},
 			postRun: func(sdkCtx sdk.Context) {
+				s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, accountAddr).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 9900)))
+				s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, addr2).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 100)))
+
 				fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, accountAddr)
 				s.Require().Contains(fromBalances, sdk.NewInt64Coin("test", 9900))
 				toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr2)
@@ -1647,6 +1732,10 @@ func (s *TestSuite) TestSubmitProposal() {
 			err := spec.req.SetMsgs(spec.msgs)
 			s.Require().NoError(err)
 
+			if spec.preRun != nil {
+				spec.preRun(spec.msgs)
+			}
+
 			res, err := s.groupKeeper.SubmitProposal(s.ctx, spec.req)
 			if spec.expErr {
 				s.Require().Error(err)
@@ -1784,6 +1873,7 @@ func (s *TestSuite) TestVote() {
 		{Address: addr4.String(), Weight: "1"},
 		{Address: addr3.String(), Weight: "2"},
 	}
+
 	groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{
 		Admin:   addr1.String(),
 		Members: members,
@@ -1802,6 +1892,8 @@ func (s *TestSuite) TestVote() {
 	}
 	err = policyReq.SetDecisionPolicy(policy)
 	s.Require().NoError(err)
+
+	s.setNextAccount()
 	policyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
 	s.Require().NoError(err)
 	accountAddr := policyRes.Address
@@ -1809,18 +1901,20 @@ func (s *TestSuite) TestVote() {
 	s.Require().NoError(err)
 	s.Require().NotNil(groupPolicy)
 
-	s.Require().NoError(testutil.FundAccount(s.bankKeeper, s.sdkCtx, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
+	s.bankKeeper.EXPECT().SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)}).Return(nil).AnyTimes()
+	s.Require().NoError(s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
 
 	req := &group.MsgSubmitProposal{
 		GroupPolicyAddress: accountAddr,
 		Proposers:          []string{addr4.String()},
 		Messages:           nil,
 	}
-	err = req.SetMsgs([]sdk.Msg{&banktypes.MsgSend{
+	msg := &banktypes.MsgSend{
 		FromAddress: accountAddr,
 		ToAddress:   addr5.String(),
 		Amount:      sdk.Coins{sdk.NewInt64Coin("test", 100)},
-	}})
+	}
+	err = req.SetMsgs([]sdk.Msg{msg})
 	s.Require().NoError(err)
 
 	proposalRes, err := s.groupKeeper.SubmitProposal(s.ctx, req)
@@ -1886,7 +1980,13 @@ func (s *TestSuite) TestVote() {
 			isFinal:           true,
 			expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED,
 			expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_SUCCESS,
+			doBefore: func(ctx context.Context) {
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msg).Return(nil, nil)
+			},
 			postRun: func(sdkCtx sdk.Context) {
+				s.bankKeeper.EXPECT().GetAllBalances(gomock.Any(), groupPolicy).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 9900)))
+				s.bankKeeper.EXPECT().GetAllBalances(gomock.Any(), addr5).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 100)))
+
 				fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, groupPolicy)
 				s.Require().Contains(fromBalances, sdk.NewInt64Coin("test", 9900))
 				toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr5)
@@ -2063,6 +2163,8 @@ func (s *TestSuite) TestVote() {
 				Option:     group.VOTE_OPTION_NO,
 			},
 			doBefore: func(ctx context.Context) {
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msg).Return(nil, nil)
+
 				_, err := s.groupKeeper.Vote(ctx, &group.MsgVote{
 					ProposalId: myProposalID,
 					Voter:      addr3.String(),
@@ -2112,8 +2214,6 @@ func (s *TestSuite) TestVote() {
 			}
 			s.Require().NoError(err)
 
-			s.Require().NoError(err)
-
 			if !(spec.expExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS) {
 				// vote is stored and all data persisted
 				res, err := s.groupKeeper.VoteByProposalVoter(ctx, &group.QueryVoteByProposalVoterRequest{
@@ -2200,6 +2300,8 @@ func (s *TestSuite) TestVote() {
 		0,
 	)
 	require.NoError(reqCreate.SetDecisionPolicy(policy))
+	s.setNextAccount()
+
 	result, err := s.groupKeeper.CreateGroupWithPolicy(s.ctx, reqCreate)
 	require.NoError(err)
 	require.NotNil(result)
@@ -2273,6 +2375,7 @@ func (s *TestSuite) TestExecProposal() {
 	}{
 		"proposal executed when accepted": {
 			setupProposal: func(ctx context.Context) uint64 {
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil)
 				msgs := []sdk.Msg{msgSend1}
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 			},
@@ -2285,6 +2388,8 @@ func (s *TestSuite) TestExecProposal() {
 		"proposal with multiple messages executed when accepted": {
 			setupProposal: func(ctx context.Context) uint64 {
 				msgs := []sdk.Msg{msgSend1, msgSend1}
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil).MaxTimes(2)
+
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 			},
 			expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED,
@@ -2335,6 +2440,7 @@ func (s *TestSuite) TestExecProposal() {
 		"prevent double execution when successful": {
 			setupProposal: func(ctx context.Context) uint64 {
 				myProposalID := submitProposalAndVote(ctx, s, []sdk.Msg{msgSend1}, proposers, group.VOTE_OPTION_YES)
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil)
 
 				_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
 				s.Require().NoError(err)
@@ -2350,6 +2456,9 @@ func (s *TestSuite) TestExecProposal() {
 		"rollback all msg updates on failure": {
 			setupProposal: func(ctx context.Context) uint64 {
 				msgs := []sdk.Msg{msgSend1, msgSend2}
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil)
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, fmt.Errorf("error"))
+
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 			},
 			expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED,
@@ -2360,10 +2469,12 @@ func (s *TestSuite) TestExecProposal() {
 				msgs := []sdk.Msg{msgSend2}
 				myProposalID := submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, fmt.Errorf("error"))
 				_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, nil)
+
 				s.Require().NoError(err)
-				sdkCtx := sdk.UnwrapSDKContext(ctx)
-				s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
+				s.Require().NoError(s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}))
 
 				return myProposalID
 			},
@@ -2407,6 +2518,9 @@ func (s *TestSuite) TestExecProposal() {
 			}
 
 			if spec.expBalance {
+				s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, s.groupPolicyAddr).Return(sdk.Coins{spec.expFromBalances})
+				s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, addr2).Return(sdk.Coins{spec.expToBalances})
+
 				fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, s.groupPolicyAddr)
 				s.Require().Contains(fromBalances, spec.expFromBalances)
 				toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr2)
@@ -2421,16 +2535,6 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 	addr1 := addrs[0]
 	addr2 := addrs[1]
 
-	msgSend1 := &banktypes.MsgSend{
-		FromAddress: s.groupPolicyAddr.String(),
-		ToAddress:   addr2.String(),
-		Amount:      sdk.Coins{sdk.NewInt64Coin("test", 100)},
-	}
-	msgSend2 := &banktypes.MsgSend{
-		FromAddress: s.groupPolicyAddr.String(),
-		ToAddress:   addr2.String(),
-		Amount:      sdk.Coins{sdk.NewInt64Coin("test", 10001)},
-	}
 	proposers := []string{addr2.String()}
 	specs := map[string]struct {
 		srcBlockTime      time.Time
@@ -2441,7 +2545,13 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 	}{
 		"proposal pruned after executor result success": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 101)},
+				}
 				msgs := []sdk.Msg{msgSend1}
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil)
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 			},
 			expErrMsg:         "load proposal: not found",
@@ -2449,6 +2559,13 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 		},
 		"proposal with multiple messages pruned when executed with result success": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 102)},
+				}
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil).MaxTimes(2)
+
 				msgs := []sdk.Msg{msgSend1, msgSend1}
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 			},
@@ -2457,6 +2574,11 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 		},
 		"proposal not pruned when not executed and rejected": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 103)},
+				}
 				msgs := []sdk.Msg{msgSend1}
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_NO)
 			},
@@ -2464,12 +2586,22 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 		},
 		"open proposal is not pruned which must not fail ": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 104)},
+				}
 				return submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers)
 			},
 			expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_NOT_RUN,
 		},
 		"proposal not pruned with group modified before tally": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 105)},
+				}
 				myProposalID := submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers)
 
 				// then modify group
@@ -2484,6 +2616,12 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 		},
 		"proposal not pruned with group policy modified before tally": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 106)},
+				}
+
 				myProposalID := submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers)
 				_, err := s.groupKeeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{
 					Admin:              addr1.String(),
@@ -2498,21 +2636,43 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() {
 		},
 		"proposal exists when rollback all msg updates on failure": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend1 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 107)},
+				}
+
+				msgSend2 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 10002)},
+				}
+
 				msgs := []sdk.Msg{msgSend1, msgSend2}
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, fmt.Errorf("error"))
+
 				return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 			},
 			expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_FAILURE,
 		},
 		"pruned when proposal is executable when failed before": {
 			setupProposal: func(ctx context.Context) uint64 {
+				msgSend2 := &banktypes.MsgSend{
+					FromAddress: s.groupPolicyAddr.String(),
+					ToAddress:   addr2.String(),
+					Amount:      sdk.Coins{sdk.NewInt64Coin("test", 10003)},
+				}
+
 				msgs := []sdk.Msg{msgSend2}
+
 				myProposalID := submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES)
 
-				_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
-				s.Require().NoError(err)
-				sdkCtx := sdk.UnwrapSDKContext(ctx)
-				s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)}))
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, fmt.Errorf("error"))
 
+				_, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID})
+				s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, nil)
+
+				s.Require().NoError(err)
 				return myProposalID
 			},
 			expErrMsg:         "load proposal: not found",
@@ -2702,7 +2862,7 @@ func (s *TestSuite) TestProposalsByVPEnd() {
 }
 
 func (s *TestSuite) TestLeaveGroup() {
-	addrs := simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, s.sdkCtx, 7, sdk.NewInt(30000000))
+	addrs := simtestutil.CreateIncrementalAccounts(7)
 
 	admin1 := addrs[0]
 	member1 := addrs[1]
@@ -2735,6 +2895,7 @@ func (s *TestSuite) TestLeaveGroup() {
 		time.Hour,
 		time.Hour,
 	)
+	s.setNextAccount()
 	_, groupID1 := s.createGroupAndGroupPolicy(admin1, members, policy)
 
 	members = []group.MemberRequest{
@@ -2744,6 +2905,8 @@ func (s *TestSuite) TestLeaveGroup() {
 			Metadata: "metadata",
 		},
 	}
+
+	s.setNextAccount()
 	_, groupID2 := s.createGroupAndGroupPolicy(admin2, members, nil)
 
 	members = []group.MemberRequest{
@@ -2763,6 +2926,8 @@ func (s *TestSuite) TestLeaveGroup() {
 		Windows:    &group.DecisionPolicyWindows{VotingPeriod: time.Hour},
 	}
 
+	s.setNextAccount()
+
 	_, groupID3 := s.createGroupAndGroupPolicy(admin3, members, policy)
 	testCases := []struct {
 		name           string
@@ -2896,6 +3061,9 @@ func (s *TestSuite) TestPruneProposals() {
 	policy := group.NewThresholdDecisionPolicy("100", time.Microsecond, time.Microsecond)
 	err := policyReq.SetDecisionPolicy(policy)
 	s.Require().NoError(err)
+
+	s.setNextAccount()
+
 	_, err = s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq)
 	s.Require().NoError(err)
 
@@ -2976,6 +3144,8 @@ func (s *TestSuite) createGroupAndGroupPolicy(
 		err = groupPolicy.SetDecisionPolicy(policy)
 		s.Require().NoError(err)
 
+		s.setNextAccount()
+
 		groupPolicyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, groupPolicy)
 		s.Require().NoError(err)
 		policyAddr = groupPolicyRes.Address

x/group/simulation/operations_test.go

@@ -23,7 +23,6 @@ import (
 	groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper"
 	"github.com/cosmos/cosmos-sdk/x/group/simulation"
 	grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil"
-	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
 )
 
 type SimTestSuite struct {
@@ -35,7 +34,6 @@ type SimTestSuite struct {
 	interfaceRegistry codectypes.InterfaceRegistry
 	accountKeeper     authkeeper.AccountKeeper
 	bankKeeper        bankkeeper.Keeper
-	stakingKeeper     *stakingkeeper.Keeper
 	groupKeeper       groupkeeper.Keeper
 }
 
@@ -46,7 +44,6 @@ func (suite *SimTestSuite) SetupTest() {
 		&suite.interfaceRegistry,
 		&suite.accountKeeper,
 		&suite.bankKeeper,
-		&suite.stakingKeeper,
 		&suite.groupKeeper,
 	)
 	suite.Require().NoError(err)

x/group/testutil/expected_keepers.go

@@ -0,0 +1,25 @@
+// This file only used to generate mocks
+
+package testutil
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	bank "github.com/cosmos/cosmos-sdk/x/bank/types"
+	"github.com/cosmos/cosmos-sdk/x/group"
+)
+
+// extends `AccountKeeper` from expected_keepers.
+type AccountKeeper interface {
+	group.AccountKeeper
+}
+
+// extends `BankKeeper` from expected_keepers.
+// extends bank `MsgServer` to mock `Send` and to register handlers in MsgServiceRouter
+type BankKeeper interface {
+	group.BankKeeper
+	bank.MsgServer
+
+	MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
+	SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
+	GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
+}

x/group/testutil/expected_keepers_mocks.go

@@ -0,0 +1,202 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: x/group/testutil/expected_keepers.go
+
+// Package testutil is a generated GoMock package.
+package testutil
+
+import (
+	context "context"
+	reflect "reflect"
+
+	types "github.com/cosmos/cosmos-sdk/types"
+	types0 "github.com/cosmos/cosmos-sdk/x/auth/types"
+	types1 "github.com/cosmos/cosmos-sdk/x/bank/types"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockAccountKeeper is a mock of AccountKeeper interface.
+type MockAccountKeeper struct {
+	ctrl     *gomock.Controller
+	recorder *MockAccountKeeperMockRecorder
+}
+
+// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper.
+type MockAccountKeeperMockRecorder struct {
+	mock *MockAccountKeeper
+}
+
+// NewMockAccountKeeper creates a new mock instance.
+func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper {
+	mock := &MockAccountKeeper{ctrl: ctrl}
+	mock.recorder = &MockAccountKeeperMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAccountKeeper) EXPECT() *MockAccountKeeperMockRecorder {
+	return m.recorder
+}
+
+// GetAccount mocks base method.
+func (m *MockAccountKeeper) GetAccount(arg0 types.Context, arg1 types.AccAddress) types0.AccountI {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAccount", arg0, arg1)
+	ret0, _ := ret[0].(types0.AccountI)
+	return ret0
+}
+
+// GetAccount indicates an expected call of GetAccount.
+func (mr *MockAccountKeeperMockRecorder) GetAccount(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetAccount), arg0, arg1)
+}
+
+// NewAccount mocks base method.
+func (m *MockAccountKeeper) NewAccount(arg0 types.Context, arg1 types0.AccountI) types0.AccountI {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NewAccount", arg0, arg1)
+	ret0, _ := ret[0].(types0.AccountI)
+	return ret0
+}
+
+// NewAccount indicates an expected call of NewAccount.
+func (mr *MockAccountKeeperMockRecorder) NewAccount(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAccount", reflect.TypeOf((*MockAccountKeeper)(nil).NewAccount), arg0, arg1)
+}
+
+// SetAccount mocks base method.
+func (m *MockAccountKeeper) SetAccount(arg0 types.Context, arg1 types0.AccountI) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetAccount", arg0, arg1)
+}
+
+// SetAccount indicates an expected call of SetAccount.
+func (mr *MockAccountKeeperMockRecorder) SetAccount(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).SetAccount), arg0, arg1)
+}
+
+// MockBankKeeper is a mock of BankKeeper interface.
+type MockBankKeeper struct {
+	ctrl     *gomock.Controller
+	recorder *MockBankKeeperMockRecorder
+}
+
+// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper.
+type MockBankKeeperMockRecorder struct {
+	mock *MockBankKeeper
+}
+
+// NewMockBankKeeper creates a new mock instance.
+func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper {
+	mock := &MockBankKeeper{ctrl: ctrl}
+	mock.recorder = &MockBankKeeperMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBankKeeper) EXPECT() *MockBankKeeperMockRecorder {
+	return m.recorder
+}
+
+// GetAllBalances mocks base method.
+func (m *MockBankKeeper) GetAllBalances(ctx types.Context, addr types.AccAddress) types.Coins {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr)
+	ret0, _ := ret[0].(types.Coins)
+	return ret0
+}
+
+// GetAllBalances indicates an expected call of GetAllBalances.
+func (mr *MockBankKeeperMockRecorder) GetAllBalances(ctx, addr interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAllBalances), ctx, addr)
+}
+
+// MintCoins mocks base method.
+func (m *MockBankKeeper) MintCoins(ctx types.Context, moduleName string, amt types.Coins) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MintCoins", ctx, moduleName, amt)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// MintCoins indicates an expected call of MintCoins.
+func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, moduleName, amt interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, moduleName, amt)
+}
+
+// MultiSend mocks base method.
+func (m *MockBankKeeper) MultiSend(arg0 context.Context, arg1 *types1.MsgMultiSend) (*types1.MsgMultiSendResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MultiSend", arg0, arg1)
+	ret0, _ := ret[0].(*types1.MsgMultiSendResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MultiSend indicates an expected call of MultiSend.
+func (mr *MockBankKeeperMockRecorder) MultiSend(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultiSend", reflect.TypeOf((*MockBankKeeper)(nil).MultiSend), arg0, arg1)
+}
+
+// Send mocks base method.
+func (m *MockBankKeeper) Send(arg0 context.Context, arg1 *types1.MsgSend) (*types1.MsgSendResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Send", arg0, arg1)
+	ret0, _ := ret[0].(*types1.MsgSendResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Send indicates an expected call of Send.
+func (mr *MockBankKeeperMockRecorder) Send(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBankKeeper)(nil).Send), arg0, arg1)
+}
+
+// SendCoinsFromModuleToAccount mocks base method.
+func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx types.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount.
+func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt)
+}
+
+// SpendableCoins mocks base method.
+func (m *MockBankKeeper) SpendableCoins(ctx types.Context, addr types.AccAddress) types.Coins {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SpendableCoins", ctx, addr)
+	ret0, _ := ret[0].(types.Coins)
+	return ret0
+}
+
+// SpendableCoins indicates an expected call of SpendableCoins.
+func (mr *MockBankKeeperMockRecorder) SpendableCoins(ctx, addr interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableCoins", reflect.TypeOf((*MockBankKeeper)(nil).SpendableCoins), ctx, addr)
+}
+
+// UpdateParams mocks base method.
+func (m *MockBankKeeper) UpdateParams(arg0 context.Context, arg1 *types1.MsgUpdateParams) (*types1.MsgUpdateParamsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateParams", arg0, arg1)
+	ret0, _ := ret[0].(*types1.MsgUpdateParamsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateParams indicates an expected call of UpdateParams.
+func (mr *MockBankKeeperMockRecorder) UpdateParams(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateParams", reflect.TypeOf((*MockBankKeeper)(nil).UpdateParams), arg0, arg1)
+}