diff --git a/.golangci.yml b/.golangci.yml
index 1dfaf42cc41..899b55f3cc7 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -10,6 +10,7 @@ run:
 linters:
   disable-all: true
   enable:
+    - errcheck
     - dogsled
     - exportloopref
     - goconst
diff --git a/baseapp/abci_test.go b/baseapp/abci_test.go
index 5487f5c371d..2436783551a 100644
--- a/baseapp/abci_test.go
+++ b/baseapp/abci_test.go
@@ -65,6 +65,7 @@ func TestABCI_First_block_Height(t *testing.T) {
 		InitialHeight:   1,
 	})
 	require.NoError(t, err)
+
 	_, err = app.Commit()
 	require.NoError(t, err)
 
@@ -185,9 +186,9 @@ func TestABCI_InitChain_WithInitialHeight(t *testing.T) {
 		},
 	)
 	require.NoError(t, err)
+
 	_, err = app.Commit()
 	require.NoError(t, err)
-
 	require.Equal(t, int64(3), app.LastBlockHeight())
 }
 
@@ -210,7 +211,6 @@ func TestABCI_FinalizeBlock_WithInitialHeight(t *testing.T) {
 	require.NoError(t, err)
 	_, err = app.Commit()
 	require.NoError(t, err)
-
 	require.Equal(t, int64(3), app.LastBlockHeight())
 }
 
@@ -391,6 +391,7 @@ func TestABCI_GRPCQuery(t *testing.T) {
 
 	_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.baseApp.LastBlockHeight() + 1})
 	require.NoError(t, err)
+
 	_, err = suite.baseApp.Commit()
 	require.NoError(t, err)
 
@@ -596,6 +597,7 @@ func TestABCI_FinalizeBlock_DeliverTx(t *testing.T) {
 
 		_, err = suite.baseApp.Commit()
 		require.NoError(t, err)
+
 	}
 }
 
@@ -646,7 +648,9 @@ func TestABCI_FinalizeBlock_MultiMsg(t *testing.T) {
 	msgs = append(msgs, &baseapptestutil.MsgCounter2{Counter: 0, Signer: addr.String()})
 	msgs = append(msgs, &baseapptestutil.MsgCounter2{Counter: 1, Signer: addr.String()})
 
-	builder.SetMsgs(msgs...)
+	err = builder.SetMsgs(msgs...)
+	require.NoError(t, err)
+
 	builder.SetMemo(tx.GetMemo())
 	setTxSignature(t, builder, 0)
 
@@ -750,12 +754,10 @@ func TestABCI_InvalidTransaction(t *testing.T) {
 		ConsensusParams: &cmtproto.ConsensusParams{},
 	})
 	require.NoError(t, err)
-
 	_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: 1,
 	})
 	require.NoError(t, err)
-
 	// malformed transaction bytes
 	{
 		bz := []byte("example vote extension")
@@ -818,7 +820,8 @@ func TestABCI_InvalidTransaction(t *testing.T) {
 	{
 		txBuilder := suite.txConfig.NewTxBuilder()
 		_, _, addr := testdata.KeyTestPubAddr()
-		txBuilder.SetMsgs(&baseapptestutil.MsgCounter2{Signer: addr.String()})
+		err = txBuilder.SetMsgs(&baseapptestutil.MsgCounter2{Signer: addr.String()})
+		require.NoError(t, err)
 		setTxSignature(t, txBuilder, 0)
 		unknownRouteTx := txBuilder.GetTx()
 
@@ -831,10 +834,11 @@ func TestABCI_InvalidTransaction(t *testing.T) {
 		require.EqualValues(t, sdkerrors.ErrUnknownRequest.ABCICode(), code, err)
 
 		txBuilder = suite.txConfig.NewTxBuilder()
-		txBuilder.SetMsgs(
+		err = txBuilder.SetMsgs(
 			&baseapptestutil.MsgCounter{Signer: addr.String()},
 			&baseapptestutil.MsgCounter2{Signer: addr.String()},
 		)
+		require.NoError(t, err)
 		setTxSignature(t, txBuilder, 0)
 		unknownRouteTx = txBuilder.GetTx()
 
@@ -850,11 +854,11 @@ func TestABCI_InvalidTransaction(t *testing.T) {
 	// Transaction with an unregistered message
 	{
 		txBuilder := suite.txConfig.NewTxBuilder()
-		txBuilder.SetMsgs(&testdata.MsgCreateDog{})
+		err = txBuilder.SetMsgs(&testdata.MsgCreateDog{})
+		require.NoError(t, err)
 		tx := txBuilder.GetTx()
 
 		_, _, err := suite.baseApp.SimDeliver(suite.txConfig.TxEncoder(), tx)
-		require.Error(t, err)
 		space, code, _ := errorsmod.ABCIInfo(err, false)
 		require.EqualValues(t, sdkerrors.ErrTxDecode.ABCICode(), code)
 		require.EqualValues(t, sdkerrors.ErrTxDecode.Codespace(), space)
@@ -1019,7 +1023,7 @@ func TestABCI_MaxBlockGasLimits(t *testing.T) {
 		tx := tc.tx
 
 		// reset block gas
-		_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.baseApp.LastBlockHeight() + 1})
+		_, err := suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.baseApp.LastBlockHeight() + 1})
 		require.NoError(t, err)
 
 		// execute the transaction multiple times
@@ -1269,7 +1273,7 @@ func TestABCI_GetBlockRetentionHeight(t *testing.T) {
 		tc := tc
 
 		tc.bapp.SetParamStore(&paramStore{db: dbm.NewMemDB()})
-		_, err = tc.bapp.InitChain(&abci.RequestInitChain{
+		_, err := tc.bapp.InitChain(&abci.RequestInitChain{
 			ConsensusParams: &cmtproto.ConsensusParams{
 				Evidence: &cmtproto.EvidenceParams{
 					MaxAgeNumBlocks: tc.maxAgeBlocks,
@@ -1474,11 +1478,11 @@ func TestABCI_Proposals_WithVE(t *testing.T) {
 
 	suite := NewBaseAppSuite(t, setInitChainerOpt, prepareOpt)
 
-	suite.baseApp.InitChain(&abci.RequestInitChain{
+	_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
 		InitialHeight:   1,
 		ConsensusParams: &cmtproto.ConsensusParams{},
 	})
-
+	require.NoError(t, err)
 	reqPrepareProposal := abci.RequestPrepareProposal{
 		MaxTxBytes: 100000,
 		Height:     1, // this value can't be 0
@@ -1573,12 +1577,12 @@ func TestABCI_PrepareProposal_MaxGas(t *testing.T) {
 	baseapptestutil.RegisterCounterServer(suite.baseApp.MsgServiceRouter(), NoopCounterServerImpl{})
 
 	// set max block gas limit to 100
-	suite.baseApp.InitChain(&abci.RequestInitChain{
+	_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
 		ConsensusParams: &cmtproto.ConsensusParams{
 			Block: &cmtproto.BlockParams{MaxGas: 100},
 		},
 	})
-
+	require.NoError(t, err)
 	// insert 100 txs, each with a gas limit of 10
 	_, _, addr := testdata.KeyTestPubAddr()
 	for i := int64(0); i < 100; i++ {
@@ -1586,7 +1590,8 @@ func TestABCI_PrepareProposal_MaxGas(t *testing.T) {
 		msgs := []sdk.Msg{msg}
 
 		builder := suite.txConfig.NewTxBuilder()
-		builder.SetMsgs(msgs...)
+		err = builder.SetMsgs(msgs...)
+		require.NoError(t, err)
 		builder.SetMemo("counter=" + strconv.FormatInt(i, 10) + "&failOnAnte=false")
 		builder.SetGasLimit(10)
 		setTxSignature(t, builder, uint64(i))
@@ -1884,13 +1889,13 @@ func TestABCI_HaltChain(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			suite := NewBaseAppSuite(t, baseapp.SetHaltHeight(tc.haltHeight), baseapp.SetHaltTime(tc.haltTime))
-			suite.baseApp.InitChain(&abci.RequestInitChain{
+			_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
 				ConsensusParams: &cmtproto.ConsensusParams{},
 				InitialHeight:   tc.blockHeight,
 			})
-
+			require.NoError(t, err)
 			app := suite.baseApp
-			_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
+			_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 				Height: tc.blockHeight,
 				Time:   time.Unix(tc.blockTime, 0),
 			})
diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go
index ea7c9f5ed66..7a8c5004692 100644
--- a/baseapp/baseapp_test.go
+++ b/baseapp/baseapp_test.go
@@ -129,7 +129,8 @@ func NewBaseAppSuiteWithSnapshots(t *testing.T, cfg SnapshotsConfig, opts ...fun
 			}
 
 			builder := suite.txConfig.NewTxBuilder()
-			builder.SetMsgs(msgs...)
+			err := builder.SetMsgs(msgs...)
+			require.NoError(t, err)
 			setTxSignature(t, builder, 0)
 
 			txBytes, err := suite.txConfig.TxEncoder()(builder.GetTx())
@@ -488,7 +489,8 @@ func TestCustomRunTxPanicHandler(t *testing.T) {
 		require.PanicsWithValue(t, customPanicMsg, func() {
 			bz, err := suite.txConfig.TxEncoder()(tx)
 			require.NoError(t, err)
-			suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: 1, Txs: [][]byte{bz}})
+			_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: 1, Txs: [][]byte{bz}})
+			require.NoError(t, err)
 		})
 	}
 }
@@ -530,7 +532,7 @@ func TestBaseAppAnteHandler(t *testing.T) {
 	// execute at tx that will pass the ante handler (the checkTx state should
 	// mutate) but will fail the message handler
 	tx = newTxCounter(t, suite.txConfig, 0, 0)
-	tx = setFailOnHandler(suite.txConfig, tx, true)
+	tx = setFailOnHandler(t, suite.txConfig, tx, true)
 
 	txBytes, err = suite.txConfig.TxEncoder()(tx)
 	require.NoError(t, err)
@@ -562,7 +564,8 @@ func TestBaseAppAnteHandler(t *testing.T) {
 	require.Equal(t, int64(2), getIntFromStore(t, store, anteKey))
 	require.Equal(t, int64(1), getIntFromStore(t, store, deliverKey))
 
-	suite.baseApp.Commit()
+	_, err = suite.baseApp.Commit()
+	require.NoError(t, err)
 }
 
 // Test and ensure that invalid block heights always cause errors.
@@ -585,7 +588,6 @@ func TestABCI_CreateQueryContext(t *testing.T) {
 	require.NoError(t, err)
 	_, err = app.Commit()
 	require.NoError(t, err)
-
 	testCases := []struct {
 		name   string
 		height int64
@@ -622,19 +624,22 @@ func TestGetMaximumBlockGas(t *testing.T) {
 	suite := NewBaseAppSuite(t)
 	_, err := suite.baseApp.InitChain(&abci.RequestInitChain{})
 	require.NoError(t, err)
-
 	ctx := suite.baseApp.NewContext(true)
 
-	suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 0}})
+	err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 0}})
+	require.NoError(t, err)
 	require.Equal(t, uint64(0), suite.baseApp.GetMaximumBlockGas(ctx))
 
-	suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -1}})
+	err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -1}})
+	require.NoError(t, err)
 	require.Equal(t, uint64(0), suite.baseApp.GetMaximumBlockGas(ctx))
 
-	suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 5000000}})
+	err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: 5000000}})
+	require.NoError(t, err)
 	require.Equal(t, uint64(5000000), suite.baseApp.GetMaximumBlockGas(ctx))
 
-	suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -5000000}})
+	err = suite.baseApp.StoreConsensusParams(ctx, cmtproto.ConsensusParams{Block: &cmtproto.BlockParams{MaxGas: -5000000}})
+	require.NoError(t, err)
 	require.Panics(t, func() { suite.baseApp.GetMaximumBlockGas(ctx) })
 }
 
diff --git a/baseapp/block_gas_test.go b/baseapp/block_gas_test.go
index 0374246c271..09b9ffe045e 100644
--- a/baseapp/block_gas_test.go
+++ b/baseapp/block_gas_test.go
@@ -117,12 +117,13 @@ func TestBaseApp_BlockGas(t *testing.T) {
 			genState := GenesisStateWithSingleValidator(t, cdc, appBuilder)
 			stateBytes, err := cmtjson.MarshalIndent(genState, "", " ")
 			require.NoError(t, err)
-			bapp.InitChain(&abci.RequestInitChain{
+			_, err = bapp.InitChain(&abci.RequestInitChain{
 				Validators:      []abci.ValidatorUpdate{},
 				ConsensusParams: simtestutil.DefaultConsensusParams,
 				AppStateBytes:   stateBytes,
 			})
 
+			require.NoError(t, err)
 			ctx := bapp.NewContext(false)
 
 			// tx fee
diff --git a/baseapp/streaming_test.go b/baseapp/streaming_test.go
index 68ab1320ef1..41f797a77b8 100644
--- a/baseapp/streaming_test.go
+++ b/baseapp/streaming_test.go
@@ -51,12 +51,12 @@ func TestABCI_MultiListener_StateChanges(t *testing.T) {
 	addListenerOpt := func(bapp *baseapp.BaseApp) { bapp.CommitMultiStore().AddListeners([]storetypes.StoreKey{distKey1}) }
 	suite := NewBaseAppSuite(t, anteOpt, distOpt, streamingManagerOpt, addListenerOpt)
 
-	suite.baseApp.InitChain(
+	_, err := suite.baseApp.InitChain(
 		&abci.RequestInitChain{
 			ConsensusParams: &tmproto.ConsensusParams{},
 		},
 	)
-
+	require.NoError(t, err)
 	deliverKey := []byte("deliver-key")
 	baseapptestutil.RegisterCounterServer(suite.baseApp.MsgServiceRouter(), CounterServerImpl{t, capKey1, deliverKey})
 
@@ -103,8 +103,8 @@ func TestABCI_MultiListener_StateChanges(t *testing.T) {
 			// require.Equal(t, sdk.MarkEventsToIndex(counterEvent(sdk.EventTypeMessage, counter).ToABCIEvents(), map[string]struct{}{})[0], events[2], "msg handler update counter event")
 		}
 
-		suite.baseApp.Commit()
-
+		_, err = suite.baseApp.Commit()
+		require.NoError(t, err)
 		require.Equal(t, expectedChangeSet, mockListener1.ChangeSet, "should contain the same changeSet")
 		require.Equal(t, expectedChangeSet, mockListener2.ChangeSet, "should contain the same changeSet")
 	}
@@ -119,9 +119,10 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
 	addListenerOpt := func(bapp *baseapp.BaseApp) { bapp.CommitMultiStore().AddListeners([]storetypes.StoreKey{distKey1}) }
 	suite := NewBaseAppSuite(t, streamingManagerOpt, addListenerOpt)
 
-	suite.baseApp.InitChain(&abci.RequestInitChain{
+	_, err := suite.baseApp.InitChain(&abci.RequestInitChain{
 		ConsensusParams: &tmproto.ConsensusParams{},
 	})
+	require.NoError(t, err)
 
 	ctx := getFinalizeBlockStateCtx(suite.baseApp)
 	sm := ctx.StreamingManager()
@@ -133,14 +134,15 @@ func Test_Ctx_with_StreamingManager(t *testing.T) {
 
 	for blockN := 0; blockN < nBlocks; blockN++ {
 
-		suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: int64(blockN) + 1})
-
+		_, err = suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: int64(blockN) + 1})
+		require.NoError(t, err)
 		ctx := getFinalizeBlockStateCtx(suite.baseApp)
 		sm := ctx.StreamingManager()
 		require.NotNil(t, sm, fmt.Sprintf("nil StreamingManager: %v", sm))
 		require.Equal(t, listeners, sm.ABCIListeners, fmt.Sprintf("should contain same listeners: %v", listeners))
 		require.Equal(t, true, sm.StopNodeOnErr, "should contain StopNodeOnErr = true")
 
-		suite.baseApp.Commit()
+		_, err = suite.baseApp.Commit()
+		require.NoError(t, err)
 	}
 }
diff --git a/baseapp/utils_test.go b/baseapp/utils_test.go
index efa670af5bd..e72de372248 100644
--- a/baseapp/utils_test.go
+++ b/baseapp/utils_test.go
@@ -339,7 +339,8 @@ func newTxCounter(t *testing.T, cfg client.TxConfig, counter int64, msgCounters
 	}
 
 	builder := cfg.NewTxBuilder()
-	builder.SetMsgs(msgs...)
+	err := builder.SetMsgs(msgs...)
+	require.NoError(t, err)
 	builder.SetMemo("counter=" + strconv.FormatInt(counter, 10) + "&failOnAnte=false")
 	setTxSignature(t, builder, uint64(counter))
 
@@ -362,8 +363,8 @@ func getIntFromStore(t *testing.T, store storetypes.KVStore, key []byte) int64 {
 func setFailOnAnte(t *testing.T, cfg client.TxConfig, tx signing.Tx, failOnAnte bool) signing.Tx {
 	t.Helper()
 	builder := cfg.NewTxBuilder()
-	builder.SetMsgs(tx.GetMsgs()...)
-
+	err := builder.SetMsgs(tx.GetMsgs()...)
+	require.NoError(t, err)
 	memo := tx.GetMemo()
 	vals, err := url.ParseQuery(memo)
 	require.NoError(t, err)
@@ -376,7 +377,8 @@ func setFailOnAnte(t *testing.T, cfg client.TxConfig, tx signing.Tx, failOnAnte
 	return builder.GetTx()
 }
 
-func setFailOnHandler(cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx {
+func setFailOnHandler(t *testing.T, cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx {
+	t.Helper()
 	builder := cfg.NewTxBuilder()
 	builder.SetMemo(tx.GetMemo())
 
@@ -388,6 +390,7 @@ func setFailOnHandler(cfg client.TxConfig, tx signing.Tx, fail bool) signing.Tx
 		}
 	}
 
-	builder.SetMsgs(msgs...)
+	err := builder.SetMsgs(msgs...)
+	require.NoError(t, err)
 	return builder.GetTx()
 }
diff --git a/client/grpc_query_test.go b/client/grpc_query_test.go
index 284f6093023..478c3c6526f 100644
--- a/client/grpc_query_test.go
+++ b/client/grpc_query_test.go
@@ -83,18 +83,20 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	s.NoError(err)
 
 	// init chain will set the validator set and initialize the genesis accounts
-	app.InitChain(&abci.RequestInitChain{
+	_, err = app.InitChain(&abci.RequestInitChain{
 		Validators:      []abci.ValidatorUpdate{},
 		ConsensusParams: sims.DefaultConsensusParams,
 		AppStateBytes:   stateBytes,
 	},
 	)
+	s.NoError(err)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height:             app.LastBlockHeight() + 1,
 		Hash:               app.LastCommitID().Hash,
 		NextValidatorsHash: valSet.Hash(),
 	})
+	s.NoError(err)
 
 	// end of app init
 
diff --git a/client/rpc/rpc_test.go b/client/rpc/rpc_test.go
index 3bd9c39ec86..1d00b51003a 100644
--- a/client/rpc/rpc_test.go
+++ b/client/rpc/rpc_test.go
@@ -100,7 +100,8 @@ func (s *IntegrationTestSuite) TestQueryABCIHeight() {
 
 	for _, tc := range testCases {
 		s.Run(tc.name, func() {
-			s.network.WaitForHeight(tc.expHeight)
+			_, err := s.network.WaitForHeight(tc.expHeight)
+			s.Require().NoError(err)
 
 			val := s.network.Validators[0]
 
diff --git a/collections/iter_test.go b/collections/iter_test.go
index dfe690bb97b..e18bad20a86 100644
--- a/collections/iter_test.go
+++ b/collections/iter_test.go
@@ -10,11 +10,13 @@ import (
 func TestIteratorBasic(t *testing.T) {
 	sk, ctx := deps()
 	// safety check to ensure that iteration does not cross prefix boundaries
-	sk.OpenKVStore(ctx).Set([]byte{0, 0}, []byte("before prefix"))
-	sk.OpenKVStore(ctx).Set([]byte{2, 1}, []byte("after prefix"))
+	err := sk.OpenKVStore(ctx).Set([]byte{0, 0}, []byte("before prefix"))
+	require.NoError(t, err)
+	err = sk.OpenKVStore(ctx).Set([]byte{2, 1}, []byte("after prefix"))
+	require.NoError(t, err)
 	schemaBuilder := NewSchemaBuilder(sk)
 	m := NewMap(schemaBuilder, NewPrefix(1), "m", StringKey, Uint64Value)
-	_, err := schemaBuilder.Build()
+	_, err = schemaBuilder.Build()
 	require.NoError(t, err)
 
 	for i := uint64(1); i <= 2; i++ {
diff --git a/crypto/keys/secp256k1/internal/secp256k1/secp256_test.go b/crypto/keys/secp256k1/internal/secp256k1/secp256_test.go
index a234683fcbf..4b0daef0def 100644
--- a/crypto/keys/secp256k1/internal/secp256k1/secp256_test.go
+++ b/crypto/keys/secp256k1/internal/secp256k1/secp256_test.go
@@ -227,7 +227,10 @@ func BenchmarkSign(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		Sign(msg, seckey)
+		_, err := Sign(msg, seckey)
+		if err != nil {
+			panic(err)
+		}
 	}
 }
 
@@ -238,6 +241,9 @@ func BenchmarkRecover(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		RecoverPubkey(msg, sig)
+		_, err := RecoverPubkey(msg, sig)
+		if err != nil {
+			panic(err)
+		}
 	}
 }
diff --git a/fuzz/tests/crypto_hd_deriveprivatekeyforpath_test.go b/fuzz/tests/crypto_hd_deriveprivatekeyforpath_test.go
index 0f235262c62..be40b785848 100644
--- a/fuzz/tests/crypto_hd_deriveprivatekeyforpath_test.go
+++ b/fuzz/tests/crypto_hd_deriveprivatekeyforpath_test.go
@@ -30,6 +30,6 @@ func FuzzCryptoHDDerivePrivateKeyForPath(f *testing.F) {
 		}
 		seed := mnemonicToSeed(string(mnemonic))
 		master, ch := hd.ComputeMastersFromSeed(seed)
-		hd.DerivePrivateKeyForPath(master, ch, string(path))
+		_, _ = hd.DerivePrivateKeyForPath(master, ch, string(path))
 	})
 }
diff --git a/fuzz/tests/crypto_hd_newparamsfrompath_test.go b/fuzz/tests/crypto_hd_newparamsfrompath_test.go
index df178d0505f..4d955c775fd 100644
--- a/fuzz/tests/crypto_hd_newparamsfrompath_test.go
+++ b/fuzz/tests/crypto_hd_newparamsfrompath_test.go
@@ -10,6 +10,6 @@ import (
 
 func FuzzCryptoHDNewParamsFromPath(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
-		hd.NewParamsFromPath(string(data))
+		_, _ = hd.NewParamsFromPath(string(data))
 	})
 }
diff --git a/fuzz/tests/types_parsecoin_test.go b/fuzz/tests/types_parsecoin_test.go
index 2204454379c..631cdcea2fe 100644
--- a/fuzz/tests/types_parsecoin_test.go
+++ b/fuzz/tests/types_parsecoin_test.go
@@ -10,6 +10,6 @@ import (
 
 func FuzzTypesParseCoin(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
-		types.ParseCoinNormalized(string(data))
+		_, _ = types.ParseCoinNormalized(string(data))
 	})
 }
diff --git a/fuzz/tests/types_parsedeccoin_test.go b/fuzz/tests/types_parsedeccoin_test.go
index a9b64e3384e..210444554b8 100644
--- a/fuzz/tests/types_parsedeccoin_test.go
+++ b/fuzz/tests/types_parsedeccoin_test.go
@@ -10,6 +10,6 @@ import (
 
 func FuzzTypesParseDecCoin(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
-		types.ParseDecCoin(string(data))
+		_, _ = types.ParseDecCoin(string(data))
 	})
 }
diff --git a/fuzz/tests/types_verifyaddressformat_test.go b/fuzz/tests/types_verifyaddressformat_test.go
index 7df912e7115..55e0014cc7c 100644
--- a/fuzz/tests/types_verifyaddressformat_test.go
+++ b/fuzz/tests/types_verifyaddressformat_test.go
@@ -10,6 +10,6 @@ import (
 
 func FuzzTypesVerifyAddressFormat(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
-		types.VerifyAddressFormat(data)
+		_ = types.VerifyAddressFormat(data)
 	})
 }
diff --git a/fuzz/tests/unknownproto_test.go b/fuzz/tests/unknownproto_test.go
index 0e2eda4aac8..9dbc2ac6022 100644
--- a/fuzz/tests/unknownproto_test.go
+++ b/fuzz/tests/unknownproto_test.go
@@ -13,7 +13,8 @@ func FuzzUnknownProto(f *testing.F) {
 	f.Fuzz(func(t *testing.T, b []byte) {
 		msg := new(testdata.TestVersion2)
 		resolver := new(unknownproto.DefaultAnyResolver)
-		unknownproto.RejectUnknownFields(b, msg, true, resolver)
-		unknownproto.RejectUnknownFields(b, msg, false, resolver)
+		_, _ = unknownproto.RejectUnknownFields(b, msg, true, resolver)
+
+		_, _ = unknownproto.RejectUnknownFields(b, msg, false, resolver)
 	})
 }
diff --git a/runtime/app.go b/runtime/app.go
index 3a2f15059de..e1ed0da78c0 100644
--- a/runtime/app.go
+++ b/runtime/app.go
@@ -139,12 +139,18 @@ func (a *App) EndBlocker(ctx sdk.Context) (sdk.EndBlock, error) {
 
 // Precommiter application updates every commit
 func (a *App) Precommiter(ctx sdk.Context) {
-	a.ModuleManager.Precommit(ctx)
+	err := a.ModuleManager.Precommit(ctx)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // PrepareCheckStater application updates every commit
 func (a *App) PrepareCheckStater(ctx sdk.Context) {
-	a.ModuleManager.PrepareCheckState(ctx)
+	err := a.ModuleManager.PrepareCheckState(ctx)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // InitChainer initializes the chain.
diff --git a/server/mock/app_test.go b/server/mock/app_test.go
index bb5bd906cc2..57496e33bae 100644
--- a/server/mock/app_test.go
+++ b/server/mock/app_test.go
@@ -42,11 +42,14 @@ func TestInitApp(t *testing.T) {
 	}
 	res, err := app.InitChain(&req)
 	require.NoError(t, err)
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Hash:   res.AppHash,
 		Height: 1,
 	})
-	app.Commit()
+	require.NoError(t, err)
+
+	_, err = app.Commit()
+	require.NoError(t, err)
 
 	// make sure we can query these values
 	query := abci.RequestQuery{
diff --git a/simapp/app_test.go b/simapp/app_test.go
index 21b478bc01d..b928549ce6d 100644
--- a/simapp/app_test.go
+++ b/simapp/app_test.go
@@ -119,8 +119,10 @@ func TestRunMigrations(t *testing.T) {
 	}
 
 	// Initialize the chain
-	app.InitChain(&abci.RequestInitChain{})
-	app.Commit()
+	_, err := app.InitChain(&abci.RequestInitChain{})
+	require.NoError(t, err)
+	_, err = app.Commit()
+	require.NoError(t, err)
 
 	testCases := []struct {
 		name         string
diff --git a/simapp/export.go b/simapp/export.go
index 3815de3d4ae..f4ac64f9f56 100644
--- a/simapp/export.go
+++ b/simapp/export.go
@@ -116,7 +116,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 	ctx = ctx.WithBlockHeight(0)
 
 	// reinitialize all validators
-	app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) {
+	err = app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) {
 		// donate any unwithdrawn outstanding reward fraction tokens to the community pool
 		scraps, err := app.DistrKeeper.GetValidatorOutstandingRewardsCoins(ctx, val.GetOperator())
 		if err != nil {
@@ -136,6 +136,9 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 		}
 		return false
 	})
+	if err != nil {
+		panic(err)
+	}
 
 	// reinitialize all delegations
 	for _, del := range dels {
@@ -162,7 +165,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 	/* Handle staking state. */
 
 	// iterate through redelegations, reset creation height
-	app.StakingKeeper.IterateRedelegations(ctx, func(_ int64, red stakingtypes.Redelegation) (stop bool) {
+	err = app.StakingKeeper.IterateRedelegations(ctx, func(_ int64, red stakingtypes.Redelegation) (stop bool) {
 		for i := range red.Entries {
 			red.Entries[i].CreationHeight = 0
 		}
@@ -172,9 +175,12 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 		}
 		return false
 	})
+	if err != nil {
+		panic(err)
+	}
 
 	// iterate through unbonding delegations, reset creation height
-	app.StakingKeeper.IterateUnbondingDelegations(ctx, func(_ int64, ubd stakingtypes.UnbondingDelegation) (stop bool) {
+	err = app.StakingKeeper.IterateUnbondingDelegations(ctx, func(_ int64, ubd stakingtypes.UnbondingDelegation) (stop bool) {
 		for i := range ubd.Entries {
 			ubd.Entries[i].CreationHeight = 0
 		}
@@ -184,7 +190,9 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 		}
 		return false
 	})
-
+	if err != nil {
+		panic(err)
+	}
 	// Iterate through validators by power descending, reset bond heights, and
 	// update bond intra-tx counters.
 	store := ctx.KVStore(app.GetKey(stakingtypes.StoreKey))
@@ -203,7 +211,9 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 			validator.Jailed = true
 		}
 
-		app.StakingKeeper.SetValidator(ctx, validator)
+		if err = app.StakingKeeper.SetValidator(ctx, validator); err != nil {
+			panic(err)
+		}
 		counter++
 	}
 
@@ -220,12 +230,18 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 	/* Handle slashing state. */
 
 	// reset start height on signing infos
-	app.SlashingKeeper.IterateValidatorSigningInfos(
+	err = app.SlashingKeeper.IterateValidatorSigningInfos(
 		ctx,
 		func(addr sdk.ConsAddress, info slashingtypes.ValidatorSigningInfo) (stop bool) {
 			info.StartHeight = 0
-			app.SlashingKeeper.SetValidatorSigningInfo(ctx, addr, info)
+			err := app.SlashingKeeper.SetValidatorSigningInfo(ctx, addr, info)
+			if err != nil {
+				panic(err)
+			}
 			return false
 		},
 	)
+	if err != nil {
+		panic(err)
+	}
 }
diff --git a/simapp/internal/testnet/cometrpc_test.go b/simapp/internal/testnet/cometrpc_test.go
index c291a0dc7ff..6e7d1a17ed3 100644
--- a/simapp/internal/testnet/cometrpc_test.go
+++ b/simapp/internal/testnet/cometrpc_test.go
@@ -76,7 +76,12 @@ func TestCometRPC_SingleRPCServer(t *testing.T) {
 
 		return cs
 	})
-	defer nodes.StopAndWait()
+	defer func() {
+		err := nodes.StopAndWait()
+		if err != nil {
+			panic(err)
+		}
+	}()
 	require.NoError(t, err)
 
 	// Once HTTP client to be shared across the following subtests.
@@ -160,8 +165,12 @@ func TestCometRPC_MultipleRPCError(t *testing.T) {
 			rootDir,
 		).RPCListen() // Every node has RPCListen enabled, which will cause a failure.
 	})
-	defer nodes.StopAndWait()
-
+	defer func() {
+		err := nodes.StopAndWait()
+		if err != nil {
+			panic(err)
+		}
+	}()
 	// Returned error is convertible to CometRPCInUseError.
 	// We can't test the exact value because it includes a stack trace.
 	require.Error(t, err)
diff --git a/simapp/internal/testnet/cometstarter_test.go b/simapp/internal/testnet/cometstarter_test.go
index 7bb814aa90b..21e1695b357 100644
--- a/simapp/internal/testnet/cometstarter_test.go
+++ b/simapp/internal/testnet/cometstarter_test.go
@@ -125,7 +125,12 @@ func TestCometStarter_PortContention(t *testing.T) {
 
 			// Ensure nodes are stopped completely,
 			// so that we don't get t.Cleanup errors around directories not being empty.
-			defer nodes.StopAndWait()
+			defer func() {
+				err := nodes.StopAndWait()
+				if err != nil {
+					panic(err)
+				}
+			}()
 			require.NoError(t, err)
 
 			// Ensure that the height advances.
diff --git a/simapp/internal/testnet/example_basic_test.go b/simapp/internal/testnet/example_basic_test.go
index 4cf603b6c32..f1a094c0815 100644
--- a/simapp/internal/testnet/example_basic_test.go
+++ b/simapp/internal/testnet/example_basic_test.go
@@ -95,13 +95,18 @@ func Example_basicUsage() {
 			dir,             // Where to put files on disk.
 		).Logger(logger.With("root_module", fmt.Sprintf("comet_%d", idx)))
 	})
-	// StopAndWait must be deferred before the error check,
-	// as the nodes value may contain some successfully started instances.
-	defer nodes.StopAndWait()
 	if err != nil {
 		panic(err)
 	}
 
+	// StopAndWait must be deferred before the error check,"os"
+	// as the nodes value may contain some successfully started instances.
+	defer func() {
+		err := nodes.StopAndWait()
+		if err != nil {
+			panic(err)
+		}
+	}()
 	// Now you can begin interacting with the nodes.
 	// For the sake of this example, we'll just check
 	// a couple simple properties of one node.
diff --git a/simapp/sim_test.go b/simapp/sim_test.go
index 53599cafc6c..f0b33efd84b 100644
--- a/simapp/sim_test.go
+++ b/simapp/sim_test.go
@@ -180,9 +180,10 @@ func TestAppImportExport(t *testing.T) {
 
 	ctxA := app.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
 	ctxB := newApp.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
-	newApp.ModuleManager.InitGenesis(ctxB, app.AppCodec(), genesisState)
-	newApp.StoreConsensusParams(ctxB, exported.ConsensusParams)
-
+	_, err = newApp.ModuleManager.InitGenesis(ctxB, app.AppCodec(), genesisState)
+	require.NoError(t, err)
+	err = newApp.StoreConsensusParams(ctxB, exported.ConsensusParams)
+	require.NoError(t, err)
 	fmt.Printf("comparing stores...\n")
 
 	// skip certain prefixes
@@ -288,11 +289,11 @@ func TestAppSimulationAfterImport(t *testing.T) {
 	newApp := NewSimApp(log.NewNopLogger(), newDB, nil, true, appOptions, fauxMerkleModeOpt, baseapp.SetChainID(SimAppChainID))
 	require.Equal(t, "SimApp", newApp.Name())
 
-	newApp.InitChain(&abci.RequestInitChain{
+	_, err = newApp.InitChain(&abci.RequestInitChain{
 		AppStateBytes: exported.AppState,
 		ChainId:       SimAppChainID,
 	})
-
+	require.NoError(t, err)
 	_, _, err = simulation.SimulateFromSeed(
 		t,
 		os.Stdout,
diff --git a/store/iavl/store.go b/store/iavl/store.go
index f9e95fd6905..3994139ff7f 100644
--- a/store/iavl/store.go
+++ b/store/iavl/store.go
@@ -216,7 +216,10 @@ func (st *Store) Has(key []byte) (exists bool) {
 // Implements types.KVStore.
 func (st *Store) Delete(key []byte) {
 	defer st.metrics.MeasureSince("store", "iavl", "delete")
-	st.tree.Remove(key)
+	_, _, err := st.tree.Remove(key)
+	if err != nil {
+		panic(err)
+	}
 }
 
 // DeleteVersionsTo deletes versions upto the given version from the MutableTree. An error
diff --git a/store/iavl/store_test.go b/store/iavl/store_test.go
index cecf74778b1..4ce0bb32179 100644
--- a/store/iavl/store_test.go
+++ b/store/iavl/store_test.go
@@ -39,13 +39,15 @@ func newAlohaTree(t *testing.T, db dbm.DB) (*iavl.MutableTree, types.CommitID) {
 	tree := iavl.NewMutableTree(db, cacheSize, false, log.NewNopLogger())
 
 	for k, v := range treeData {
-		tree.Set([]byte(k), []byte(v))
+		_, err := tree.Set([]byte(k), []byte(v))
+		require.NoError(t, err)
 	}
 
 	for i := 0; i < nMoreData; i++ {
 		key := randBytes(12)
 		value := randBytes(50)
-		tree.Set(key, value)
+		_, err := tree.Set(key, value)
+		require.NoError(t, err)
 	}
 
 	hash, ver, err := tree.SaveVersion()
@@ -583,7 +585,8 @@ func BenchmarkIAVLIteratorNext(b *testing.B) {
 	for i := 0; i < treeSize; i++ {
 		key := randBytes(4)
 		value := randBytes(50)
-		tree.Set(key, value)
+		_, err := tree.Set(key, value)
+		require.NoError(b, err)
 	}
 
 	iavlStore := UnsafeNewStore(tree)
diff --git a/store/iavl/tree_test.go b/store/iavl/tree_test.go
index 4e837262ae1..63a12a2e5d2 100644
--- a/store/iavl/tree_test.go
+++ b/store/iavl/tree_test.go
@@ -14,8 +14,14 @@ func TestImmutableTreePanics(t *testing.T) {
 	t.Parallel()
 	immTree := iavl.NewImmutableTree(dbm.NewMemDB(), 100, false, log.NewNopLogger())
 	it := &immutableTree{immTree}
-	require.Panics(t, func() { it.Set([]byte{}, []byte{}) })
-	require.Panics(t, func() { it.Remove([]byte{}) })
+	require.Panics(t, func() {
+		_, err := it.Set([]byte{}, []byte{})
+		require.NoError(t, err)
+	})
+	require.Panics(t, func() {
+		_, _, err := it.Remove([]byte{})
+		require.NoError(t, err)
+	})
 	require.Panics(t, func() { _, _, _ = it.SaveVersion() })
 	require.Panics(t, func() { _ = it.DeleteVersionsTo(int64(1)) })
 
diff --git a/store/rootmulti/snapshot_test.go b/store/rootmulti/snapshot_test.go
index 723391e2bbe..635be92970a 100644
--- a/store/rootmulti/snapshot_test.go
+++ b/store/rootmulti/snapshot_test.go
@@ -33,7 +33,10 @@ func newMultiStoreWithGeneratedData(db dbm.DB, stores uint8, storeKeys uint64) *
 		multiStore.MountStoreWithDB(key, types.StoreTypeIAVL, nil)
 		keys = append(keys, key)
 	}
-	multiStore.LoadLatestVersion()
+	err := multiStore.LoadLatestVersion()
+	if err != nil {
+		panic(err)
+	}
 
 	for _, key := range keys {
 		store := multiStore.GetCommitKVStore(key).(*iavl.Store)
@@ -50,7 +53,10 @@ func newMultiStoreWithGeneratedData(db dbm.DB, stores uint8, storeKeys uint64) *
 	}
 
 	multiStore.Commit()
-	multiStore.LoadLatestVersion()
+	err = multiStore.LoadLatestVersion()
+	if err != nil {
+		panic(err)
+	}
 
 	return multiStore
 }
@@ -61,8 +67,9 @@ func newMultiStoreWithMixedMounts(db dbm.DB) *rootmulti.Store {
 	store.MountStoreWithDB(types.NewKVStoreKey("iavl2"), types.StoreTypeIAVL, nil)
 	store.MountStoreWithDB(types.NewKVStoreKey("iavl3"), types.StoreTypeIAVL, nil)
 	store.MountStoreWithDB(types.NewTransientStoreKey("trans1"), types.StoreTypeTransient, nil)
-	store.LoadLatestVersion()
-
+	if err := store.LoadLatestVersion(); err != nil {
+		panic(err)
+	}
 	return store
 }
 
diff --git a/store/rootmulti/store.go b/store/rootmulti/store.go
index 1b0a64857dd..7fe7f048bf0 100644
--- a/store/rootmulti/store.go
+++ b/store/rootmulti/store.go
@@ -1205,7 +1205,10 @@ func flushCommitInfo(batch dbm.Batch, version int64, cInfo *types.CommitInfo) {
 	}
 
 	cInfoKey := fmt.Sprintf(commitInfoKeyFmt, version)
-	batch.Set([]byte(cInfoKey), bz)
+	err = batch.Set([]byte(cInfoKey), bz)
+	if err != nil {
+		panic(err)
+	}
 }
 
 func flushLatestVersion(batch dbm.Batch, version int64) {
@@ -1214,5 +1217,8 @@ func flushLatestVersion(batch dbm.Batch, version int64) {
 		panic(err)
 	}
 
-	batch.Set([]byte(latestVersionKey), bz)
+	err = batch.Set([]byte(latestVersionKey), bz)
+	if err != nil {
+		panic(err)
+	}
 }
diff --git a/store/rootmulti/store_test.go b/store/rootmulti/store_test.go
index 34854fe83ce..df69e2ab734 100644
--- a/store/rootmulti/store_test.go
+++ b/store/rootmulti/store_test.go
@@ -648,7 +648,8 @@ func TestSetInitialVersion(t *testing.T) {
 
 	require.NoError(t, multi.LoadLatestVersion())
 
-	multi.SetInitialVersion(5)
+	err := multi.SetInitialVersion(5)
+	require.NoError(t, err)
 	require.Equal(t, int64(5), multi.initialVersion)
 
 	multi.Commit()
@@ -916,13 +917,15 @@ func (stub *commitKVStoreStub) Commit() types.CommitID {
 	return commitID
 }
 
-func prepareStoreMap() map[types.StoreKey]types.CommitKVStore {
+func prepareStoreMap() (map[types.StoreKey]types.CommitKVStore, error) {
 	var db dbm.DB = dbm.NewMemDB()
 	store := NewStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics())
 	store.MountStoreWithDB(types.NewKVStoreKey("iavl1"), types.StoreTypeIAVL, nil)
 	store.MountStoreWithDB(types.NewKVStoreKey("iavl2"), types.StoreTypeIAVL, nil)
 	store.MountStoreWithDB(types.NewTransientStoreKey("trans1"), types.StoreTypeTransient, nil)
-	store.LoadLatestVersion()
+	if err := store.LoadLatestVersion(); err != nil {
+		return nil, err
+	}
 	return map[types.StoreKey]types.CommitKVStore{
 		testStoreKey1: &commitKVStoreStub{
 			CommitKVStore: store.GetStoreByName("iavl1").(types.CommitKVStore),
@@ -933,7 +936,7 @@ func prepareStoreMap() map[types.StoreKey]types.CommitKVStore {
 		testStoreKey3: &commitKVStoreStub{
 			CommitKVStore: store.GetStoreByName("trans1").(types.CommitKVStore),
 		},
-	}
+	}, nil
 }
 
 func TestCommitStores(t *testing.T) {
@@ -960,7 +963,8 @@ func TestCommitStores(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			storeMap := prepareStoreMap()
+			storeMap, err := prepareStoreMap()
+			require.NoError(t, err)
 			store := storeMap[testStoreKey1].(*commitKVStoreStub)
 			for i := tc.committed; i > 0; i-- {
 				store.Commit()
diff --git a/store/tracekv/store.go b/store/tracekv/store.go
index 874f38b2481..8e3a14e1f97 100644
--- a/store/tracekv/store.go
+++ b/store/tracekv/store.go
@@ -195,5 +195,8 @@ func writeOperation(w io.Writer, op operation, tc types.TraceContext, key, value
 		panic(errors.Wrap(err, "failed to write trace operation"))
 	}
 
-	io.WriteString(w, "\n")
+	_, err = io.WriteString(w, "\n")
+	if err != nil {
+		panic(err)
+	}
 }
diff --git a/tests/e2e/auth/suite.go b/tests/e2e/auth/suite.go
index 8209a6fd4a4..1951dabd7f4 100644
--- a/tests/e2e/auth/suite.go
+++ b/tests/e2e/auth/suite.go
@@ -1340,10 +1340,11 @@ func (s *E2ETestSuite) TestSignWithMultiSignersAminoJSON() {
 	// because DIRECT doesn't support multi signers via the CLI.
 	// Since we use amino, we don't need to pre-populate signer_infos.
 	txBuilder := val0.ClientCtx.TxConfig.NewTxBuilder()
-	txBuilder.SetMsgs(
+	err := txBuilder.SetMsgs(
 		banktypes.NewMsgSend(val0.Address, addr1, sdk.NewCoins(val0Coin)),
 		banktypes.NewMsgSend(val1.Address, addr1, sdk.NewCoins(val1Coin)),
 	)
+	require.NoError(err)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, math.NewInt(10))))
 	txBuilder.SetGasLimit(testdata.NewTestGasLimit() * 2)
 	signers, err := txBuilder.GetTx().GetSigners()
diff --git a/tests/e2e/authz/grpc.go b/tests/e2e/authz/grpc.go
index 98de0bd91ee..bebabd79ce0 100644
--- a/tests/e2e/authz/grpc.go
+++ b/tests/e2e/authz/grpc.go
@@ -74,7 +74,8 @@ func (s *E2ETestSuite) TestQueryGrantGRPC() {
 				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &g)
 				require.NoError(err)
 				require.Len(g.Grants, 1)
-				g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry)
+				err = g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry)
+				require.NoError(err)
 				auth, err := g.Grants[0].GetAuthorization()
 				require.NoError(err)
 				require.Equal(auth.MsgTypeURL(), banktypes.SendAuthorization{}.MsgTypeURL())
diff --git a/tests/e2e/staking/suite.go b/tests/e2e/staking/suite.go
index d3bc994612d..c88f5ad74e7 100644
--- a/tests/e2e/staking/suite.go
+++ b/tests/e2e/staking/suite.go
@@ -133,7 +133,7 @@ func (s *E2ETestSuite) TestBlockResults() {
 
 	// Loop until we find a block result with the correct validator updates.
 	// By experience, it happens around 2 blocks after `delHeight`.
-	s.network.RetryForBlocks(func() error {
+	_ = s.network.RetryForBlocks(func() error {
 		latestHeight, err := s.network.LatestHeight()
 		require.NoError(err)
 		res, err := rpcClient.BlockResults(context.Background(), &latestHeight)
diff --git a/tests/integration/auth/client/cli/suite_test.go b/tests/integration/auth/client/cli/suite_test.go
index f618c64b8d6..3955ee35f1a 100644
--- a/tests/integration/auth/client/cli/suite_test.go
+++ b/tests/integration/auth/client/cli/suite_test.go
@@ -881,10 +881,11 @@ func (s *CLITestSuite) TestSignWithMultiSignersAminoJSON() {
 	// because DIRECT doesn't support multi signers via the CLI.
 	// Since we use amino, we don't need to pre-populate signer_infos.
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
-	txBuilder.SetMsgs(
+	err := txBuilder.SetMsgs(
 		banktypes.NewMsgSend(val0, addr1, sdk.NewCoins(val0Coin)),
 		banktypes.NewMsgSend(val1, addr1, sdk.NewCoins(val1Coin)),
 	)
+	s.Require().NoError(err)
 	txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("stake", math.NewInt(10))))
 	txBuilder.SetGasLimit(testdata.NewTestGasLimit() * 2)
 	signers, err := txBuilder.GetTx().GetSigners()
diff --git a/tests/integration/auth/migrations/v2/store_test.go b/tests/integration/auth/migrations/v2/store_test.go
index e47419d291c..ca25f97ecd7 100644
--- a/tests/integration/auth/migrations/v2/store_test.go
+++ b/tests/integration/auth/migrations/v2/store_test.go
@@ -74,7 +74,8 @@ func TestMigrateVestingAccounts(t *testing.T) {
 	require.NoError(t, v4.Migrate(ctx, storeService, legacySubspace, cdc))
 
 	ctx = app.BaseApp.NewContextLegacy(false, cmtproto.Header{Time: time.Now()})
-	stakingKeeper.SetParams(ctx, stakingtypes.DefaultParams())
+	err = stakingKeeper.SetParams(ctx, stakingtypes.DefaultParams())
+	require.NoError(t, err)
 	lastAccNum := uint64(1000)
 	createBaseAccount := func(addr sdk.AccAddress) *authtypes.BaseAccount {
 		baseAccount := authtypes.NewBaseAccountWithAddress(addr)
@@ -778,14 +779,15 @@ func createValidator(t *testing.T, ctx sdk.Context, bankKeeper bankkeeper.Keeper
 	val1, err := stakingtypes.NewValidator(valAddrs[0], pks[0], stakingtypes.Description{})
 	require.NoError(t, err)
 
-	stakingKeeper.SetValidator(ctx, val1)
+	require.NoError(t, stakingKeeper.SetValidator(ctx, val1))
 	require.NoError(t, stakingKeeper.SetValidatorByConsAddr(ctx, val1))
-	stakingKeeper.SetNewValidatorByPowerIndex(ctx, val1)
+	require.NoError(t, stakingKeeper.SetNewValidatorByPowerIndex(ctx, val1))
 
 	_, err = stakingKeeper.Delegate(ctx, addrs[0], valTokens, stakingtypes.Unbonded, val1, true)
 	require.NoError(t, err)
 
-	stakingKeeper.EndBlocker(ctx)
+	_, err = stakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
 
 	return addrs[0], valAddrs[0]
 }
diff --git a/tests/integration/bank/keeper/deterministic_test.go b/tests/integration/bank/keeper/deterministic_test.go
index 35370654831..7928c47bf28 100644
--- a/tests/integration/bank/keeper/deterministic_test.go
+++ b/tests/integration/bank/keeper/deterministic_test.go
@@ -313,7 +313,8 @@ func TestGRPCQueryParams(t *testing.T) {
 			DefaultSendEnabled: rapid.Bool().Draw(rt, "send"),
 		}
 
-		f.bankKeeper.SetParams(f.ctx, params)
+		err := f.bankKeeper.SetParams(f.ctx, params)
+		assert.NilError(t, err)
 
 		req := &banktypes.QueryParamsRequest{}
 		testdata.DeterministicIterations(f.ctx, t, req, f.queryClient.Params, 0, true)
@@ -329,8 +330,8 @@ func TestGRPCQueryParams(t *testing.T) {
 		DefaultSendEnabled: false,
 	}
 
-	f.bankKeeper.SetParams(f.ctx, params)
-
+	err := f.bankKeeper.SetParams(f.ctx, params)
+	assert.NilError(t, err)
 	req := &banktypes.QueryParamsRequest{}
 	testdata.DeterministicIterations(f.ctx, t, req, f.queryClient.Params, 1003, false)
 }
diff --git a/tests/integration/distribution/keeper/msg_server_test.go b/tests/integration/distribution/keeper/msg_server_test.go
index 3315e2f7a62..7901fa09b1c 100644
--- a/tests/integration/distribution/keeper/msg_server_test.go
+++ b/tests/integration/distribution/keeper/msg_server_test.go
@@ -199,8 +199,7 @@ func TestMsgWithdrawDelegatorReward(t *testing.T) {
 	validator, issuedShares := validator.AddTokensFromDel(delTokens)
 	delegation := stakingtypes.NewDelegation(delAddr, validator.GetOperator(), issuedShares)
 	require.NoError(t, f.stakingKeeper.SetDelegation(f.sdkCtx, delegation))
-	err = f.distrKeeper.DelegatorStartingInfo.Set(f.sdkCtx, collections.Join(validator.GetOperator(), delAddr), distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 20))
-	require.NoError(t, err)
+	require.NoError(t, f.distrKeeper.DelegatorStartingInfo.Set(f.sdkCtx, collections.Join(validator.GetOperator(), delAddr), distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 20)))
 	// setup validator rewards
 	decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())}
 	historicalRewards := distrtypes.NewValidatorHistoricalRewards(decCoins, 2)
diff --git a/tests/integration/evidence/keeper/infraction_test.go b/tests/integration/evidence/keeper/infraction_test.go
index 9c69aa12735..ce5841456fe 100644
--- a/tests/integration/evidence/keeper/infraction_test.go
+++ b/tests/integration/evidence/keeper/infraction_test.go
@@ -196,11 +196,11 @@ func TestHandleDoubleSign(t *testing.T) {
 	assert.NilError(t, f.slashingKeeper.AddPubkey(f.sdkCtx, valpubkey))
 
 	info := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(valpubkey.Address()), f.sdkCtx.BlockHeight(), int64(0), time.Unix(0, 0), false, int64(0))
-	f.slashingKeeper.SetValidatorSigningInfo(f.sdkCtx, sdk.ConsAddress(valpubkey.Address()), info)
-
+	err = f.slashingKeeper.SetValidatorSigningInfo(f.sdkCtx, sdk.ConsAddress(valpubkey.Address()), info)
+	assert.NilError(t, err)
 	// handle a signature to set signing info
-	f.slashingKeeper.HandleValidatorSignature(ctx, valpubkey.Address(), selfDelegation.Int64(), comet.BlockIDFlagCommit)
-
+	err = f.slashingKeeper.HandleValidatorSignature(ctx, valpubkey.Address(), selfDelegation.Int64(), comet.BlockIDFlagCommit)
+	assert.NilError(t, err)
 	// double sign less than max age
 	val, err = f.stakingKeeper.Validator(ctx, operatorAddr)
 	assert.NilError(t, err)
diff --git a/tests/integration/gov/keeper/common_test.go b/tests/integration/gov/keeper/common_test.go
index 4db7f97047a..c642ff1f179 100644
--- a/tests/integration/gov/keeper/common_test.go
+++ b/tests/integration/gov/keeper/common_test.go
@@ -48,21 +48,21 @@ func createValidators(t *testing.T, f *fixture, powers []int64) ([]sdk.AccAddres
 	val3, err := stakingtypes.NewValidator(valAddrs[2], pks[2], stakingtypes.Description{})
 	assert.NilError(t, err)
 
-	f.stakingKeeper.SetValidator(f.ctx, val1)
-	f.stakingKeeper.SetValidator(f.ctx, val2)
-	f.stakingKeeper.SetValidator(f.ctx, val3)
-	f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val1)
-	f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val2)
-	f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val3)
-	f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val1)
-	f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val2)
-	f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val3)
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.ctx, val1))
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.ctx, val2))
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.ctx, val3))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val1))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val2))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.ctx, val3))
+	assert.NilError(t, f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val1))
+	assert.NilError(t, f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val2))
+	assert.NilError(t, f.stakingKeeper.SetNewValidatorByPowerIndex(f.ctx, val3))
 
 	_, _ = f.stakingKeeper.Delegate(f.ctx, addrs[0], f.stakingKeeper.TokensFromConsensusPower(f.ctx, powers[0]), stakingtypes.Unbonded, val1, true)
 	_, _ = f.stakingKeeper.Delegate(f.ctx, addrs[1], f.stakingKeeper.TokensFromConsensusPower(f.ctx, powers[1]), stakingtypes.Unbonded, val2, true)
 	_, _ = f.stakingKeeper.Delegate(f.ctx, addrs[2], f.stakingKeeper.TokensFromConsensusPower(f.ctx, powers[2]), stakingtypes.Unbonded, val3, true)
 
-	f.stakingKeeper.EndBlocker(f.ctx)
-
+	_, err = f.stakingKeeper.EndBlocker(f.ctx)
+	assert.NilError(t, err)
 	return addrs, valAddrs
 }
diff --git a/tests/integration/gov/keeper/grpc_query_test.go b/tests/integration/gov/keeper/grpc_query_test.go
index 87ff8868300..3a27b054252 100644
--- a/tests/integration/gov/keeper/grpc_query_test.go
+++ b/tests/integration/gov/keeper/grpc_query_test.go
@@ -79,8 +79,8 @@ func TestGRPCQueryTally(t *testing.T) {
 			"request tally after few votes",
 			func() {
 				proposal.Status = v1.StatusVotingPeriod
-				f.govKeeper.SetProposal(ctx, proposal)
-
+				err := f.govKeeper.SetProposal(ctx, proposal)
+				assert.NilError(t, err)
 				assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 				assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 				assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -103,7 +103,8 @@ func TestGRPCQueryTally(t *testing.T) {
 			"request final tally after status changed",
 			func() {
 				proposal.Status = v1.StatusPassed
-				f.govKeeper.SetProposal(ctx, proposal)
+				err := f.govKeeper.SetProposal(ctx, proposal)
+				assert.NilError(t, err)
 				proposal, _ = f.govKeeper.Proposals.Get(ctx, proposal.Id)
 
 				req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
@@ -201,8 +202,8 @@ func TestLegacyGRPCQueryTally(t *testing.T) {
 			"request tally after few votes",
 			func() {
 				proposal.Status = v1.StatusVotingPeriod
-				f.govKeeper.SetProposal(ctx, proposal)
-
+				err := f.govKeeper.SetProposal(ctx, proposal)
+				assert.NilError(t, err)
 				assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 				assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 				assert.NilError(t, f.govKeeper.AddVote(ctx, proposal.Id, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -225,7 +226,8 @@ func TestLegacyGRPCQueryTally(t *testing.T) {
 			"request final tally after status changed",
 			func() {
 				proposal.Status = v1.StatusPassed
-				f.govKeeper.SetProposal(ctx, proposal)
+				err := f.govKeeper.SetProposal(ctx, proposal)
+				assert.NilError(t, err)
 				proposal, _ = f.govKeeper.Proposals.Get(ctx, proposal.Id)
 
 				req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
diff --git a/tests/integration/gov/keeper/keeper_test.go b/tests/integration/gov/keeper/keeper_test.go
index 65e993ff8df..bc1efa7c32b 100644
--- a/tests/integration/gov/keeper/keeper_test.go
+++ b/tests/integration/gov/keeper/keeper_test.go
@@ -96,8 +96,8 @@ func initFixture(tb testing.TB) *fixture {
 	stakingKeeper := stakingkeeper.NewKeeper(cdc, runtime.NewKVStoreService(keys[stakingtypes.StoreKey]), accountKeeper, bankKeeper, authority.String())
 
 	// set default staking params
-	stakingKeeper.SetParams(newCtx, stakingtypes.DefaultParams())
-
+	err := stakingKeeper.SetParams(newCtx, stakingtypes.DefaultParams())
+	assert.NilError(tb, err)
 	distrKeeper := distrkeeper.NewKeeper(
 		cdc, runtime.NewKVStoreService(keys[distrtypes.StoreKey]), accountKeeper, bankKeeper, stakingKeeper, distrtypes.ModuleName, authority.String(),
 	)
@@ -118,8 +118,7 @@ func initFixture(tb testing.TB) *fixture {
 		types.DefaultConfig(),
 		authority.String(),
 	)
-	err := govKeeper.ProposalID.Set(newCtx, 1)
-	assert.NilError(tb, err)
+	assert.NilError(tb, govKeeper.ProposalID.Set(newCtx, 1))
 	govRouter := v1beta1.NewRouter()
 	govRouter.AddRoute(types.RouterKey, v1beta1.ProposalHandler)
 	govKeeper.SetLegacyRouter(govRouter)
diff --git a/tests/integration/gov/keeper/tally_test.go b/tests/integration/gov/keeper/tally_test.go
index 926556be24a..a30ff271846 100644
--- a/tests/integration/gov/keeper/tally_test.go
+++ b/tests/integration/gov/keeper/tally_test.go
@@ -26,8 +26,8 @@ func TestTallyNoOneVotes(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	proposal, ok := f.govKeeper.Proposals.Get(ctx, proposalID)
 	assert.Assert(t, ok)
 	passes, burnDeposits, tallyResults, _ := f.govKeeper.Tally(ctx, proposal)
@@ -53,8 +53,8 @@ func TestTallyNoQuorum(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	err = f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), "")
 	assert.NilError(t, err)
 
@@ -79,8 +79,8 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -108,8 +108,8 @@ func TestTallyOnlyValidators51No(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 
@@ -135,8 +135,8 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 
@@ -163,8 +163,8 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[2], v1.NewNonSplitVoteOption(v1.OptionNoWithVeto), ""))
@@ -192,8 +192,8 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -221,8 +221,8 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddrs[2], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@@ -251,8 +251,8 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddr1, v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, valAccAddr2, v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 
@@ -281,15 +281,15 @@ func TestTallyDelgatorOverride(t *testing.T) {
 	_, err := f.stakingKeeper.Delegate(ctx, addrs[4], delTokens, stakingtypes.Unbonded, val1, true)
 	assert.NilError(t, err)
 
-	f.stakingKeeper.EndBlocker(ctx)
-
+	_, err = f.stakingKeeper.EndBlocker(ctx)
+	assert.NilError(t, err)
 	tp := TestProposal
 	proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[3], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -320,15 +320,15 @@ func TestTallyDelgatorInherit(t *testing.T) {
 	_, err := f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true)
 	assert.NilError(t, err)
 
-	f.stakingKeeper.EndBlocker(ctx)
-
+	_, err = f.stakingKeeper.EndBlocker(ctx)
+	assert.NilError(t, err)
 	tp := TestProposal
 	proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -362,15 +362,15 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	_, err = f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val2, true)
 	assert.NilError(t, err)
 
-	f.stakingKeeper.EndBlocker(ctx)
-
+	_, err = f.stakingKeeper.EndBlocker(ctx)
+	assert.NilError(t, err)
 	tp := TestProposal
 	proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
@@ -407,15 +407,15 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 	_, err = f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true)
 	assert.NilError(t, err)
 
-	f.stakingKeeper.EndBlocker(ctx)
-
+	_, err = f.stakingKeeper.EndBlocker(ctx)
+	assert.NilError(t, err)
 	tp := TestProposal
 	proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@@ -449,19 +449,19 @@ func TestTallyJailedValidator(t *testing.T) {
 	_, err = f.stakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true)
 	assert.NilError(t, err)
 
-	f.stakingKeeper.EndBlocker(ctx)
-
+	_, err = f.stakingKeeper.EndBlocker(ctx)
+	assert.NilError(t, err)
 	consAddr, err := val2.GetConsAddr()
 	assert.NilError(t, err)
-	f.stakingKeeper.Jail(ctx, sdk.ConsAddress(consAddr.Bytes()))
+	assert.NilError(t, f.stakingKeeper.Jail(ctx, sdk.ConsAddress(consAddr.Bytes())))
 
 	tp := TestProposal
 	proposal, err := f.govKeeper.SubmitProposal(ctx, tp, "", "test", "description", addrs[0], false)
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
@@ -496,8 +496,8 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
 	assert.NilError(t, err)
 	proposalID := proposal.Id
 	proposal.Status = v1.StatusVotingPeriod
-	f.govKeeper.SetProposal(ctx, proposal)
-
+	err = f.govKeeper.SetProposal(ctx, proposal)
+	assert.NilError(t, err)
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[1], v1.NewNonSplitVoteOption(v1.OptionNo), ""))
 	assert.NilError(t, f.govKeeper.AddVote(ctx, proposalID, addrs[2], v1.NewNonSplitVoteOption(v1.OptionYes), ""))
diff --git a/tests/integration/slashing/keeper/keeper_test.go b/tests/integration/slashing/keeper/keeper_test.go
index 8ee839168d4..c4d912ee671 100644
--- a/tests/integration/slashing/keeper/keeper_test.go
+++ b/tests/integration/slashing/keeper/keeper_test.go
@@ -114,19 +114,21 @@ func initFixture(tb testing.TB) *fixture {
 	slashingtypes.RegisterQueryServer(integrationApp.QueryHelper(), slashingkeeper.NewQuerier(slashingKeeper))
 
 	// set default staking params
-	stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams())
-
+	err := stakingKeeper.SetParams(sdkCtx, stakingtypes.DefaultParams())
+	assert.NilError(tb, err)
 	// TestParams set the SignedBlocksWindow to 1000 and MaxMissedBlocksPerWindow to 500
-	slashingKeeper.Params.Set(sdkCtx, testutil.TestParams())
+	err = slashingKeeper.Params.Set(sdkCtx, testutil.TestParams())
+	assert.NilError(tb, err)
 	addrDels := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, sdkCtx, 6, stakingKeeper.TokensFromConsensusPower(sdkCtx, 200))
 	valAddrs := simtestutil.ConvertAddrsToValAddrs(addrDels)
 
 	info1 := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3), time.Unix(2, 0), false, int64(10))
 	info2 := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[1]), int64(5), int64(4), time.Unix(2, 0), false, int64(10))
 
-	slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[0]), info1)
-	slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[1]), info2)
-
+	err = slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[0]), info1)
+	assert.NilError(tb, err)
+	err = slashingKeeper.SetValidatorSigningInfo(sdkCtx, sdk.ConsAddress(addrDels[1]), info2)
+	assert.NilError(tb, err)
 	return &fixture{
 		app:            integrationApp,
 		ctx:            sdkCtx,
@@ -145,8 +147,7 @@ func TestUnJailNotBonded(t *testing.T) {
 	p, err := f.stakingKeeper.GetParams(f.ctx)
 	assert.NilError(t, err)
 	p.MaxValidators = 5
-	f.stakingKeeper.SetParams(f.ctx, p)
-
+	assert.NilError(t, f.stakingKeeper.SetParams(f.ctx, p))
 	pks := simtestutil.CreateTestPubKeys(6)
 	tstaking := stakingtestutil.NewHelper(t, f.ctx, f.stakingKeeper)
 
@@ -156,7 +157,8 @@ func TestUnJailNotBonded(t *testing.T) {
 		tstaking.CreateValidatorWithValPower(addr, val, 100, true)
 	}
 
-	f.stakingKeeper.EndBlocker(f.ctx)
+	_, err = f.stakingKeeper.EndBlocker(f.ctx)
+	assert.NilError(t, err)
 	f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
 
 	// create a 6th validator with less power than the cliff validator (won't be bonded)
@@ -169,7 +171,8 @@ func TestUnJailNotBonded(t *testing.T) {
 	assert.NilError(t, err)
 	assert.Assert(t, res != nil)
 
-	f.stakingKeeper.EndBlocker(f.ctx)
+	_, err = f.stakingKeeper.EndBlocker(f.ctx)
+	assert.NilError(t, err)
 	f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
 
 	tstaking.CheckValidator(addr, stakingtypes.Unbonded, false)
@@ -178,7 +181,8 @@ func TestUnJailNotBonded(t *testing.T) {
 	assert.Equal(t, p.BondDenom, tstaking.Denom)
 	tstaking.Undelegate(sdk.AccAddress(addr), addr, f.stakingKeeper.TokensFromConsensusPower(f.ctx, 1), true)
 
-	f.stakingKeeper.EndBlocker(f.ctx)
+	_, err = f.stakingKeeper.EndBlocker(f.ctx)
+	assert.NilError(t, err)
 	f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
 
 	// verify that validator is jailed
@@ -195,12 +199,14 @@ func TestUnJailNotBonded(t *testing.T) {
 	)
 	assert.ErrorContains(t, err, "cannot be unjailed")
 
-	f.stakingKeeper.EndBlocker(f.ctx)
+	_, err = f.stakingKeeper.EndBlocker(f.ctx)
+	assert.NilError(t, err)
 	f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
 	// bond to meet minimum self-delegation
 	tstaking.DelegateWithPower(sdk.AccAddress(addr), addr, 1)
 
-	f.stakingKeeper.EndBlocker(f.ctx)
+	_, err = f.stakingKeeper.EndBlocker(f.ctx)
+	assert.NilError(t, err)
 	f.ctx = f.ctx.WithBlockHeight(f.ctx.BlockHeight() + 1)
 
 	// verify we can immediately unjail
@@ -345,7 +351,8 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	params, err := f.stakingKeeper.GetParams(f.ctx)
 	require.NoError(t, err)
 	params.MaxValidators = 1
-	f.stakingKeeper.SetParams(f.ctx, params)
+	err = f.stakingKeeper.SetParams(f.ctx, params)
+	assert.NilError(t, err)
 	power := int64(100)
 
 	pks := simtestutil.CreateTestPubKeys(3)
@@ -439,8 +446,8 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	assert.NilError(t, err)
 
 	// validator rejoins and starts signing again
-	f.stakingKeeper.Unjail(f.ctx, consAddr)
-
+	err = f.stakingKeeper.Unjail(f.ctx, consAddr)
+	assert.NilError(t, err)
 	err = f.slashingKeeper.HandleValidatorSignature(f.ctx, val.Address(), newPower, comet.BlockIDFlagCommit)
 	assert.NilError(t, err)
 
diff --git a/tests/integration/staking/keeper/validator_bench_test.go b/tests/integration/staking/keeper/validator_bench_test.go
index c8f83c44079..c909db25cf2 100644
--- a/tests/integration/staking/keeper/validator_bench_test.go
+++ b/tests/integration/staking/keeper/validator_bench_test.go
@@ -27,7 +27,9 @@ func BenchmarkGetValidator(b *testing.B) {
 	f, _, valAddrs, vals := initValidators(b, totalPower, len(powers), powers)
 
 	for _, validator := range vals {
-		f.stakingKeeper.SetValidator(f.sdkCtx, validator)
+		if err := f.stakingKeeper.SetValidator(f.sdkCtx, validator); err != nil {
+			panic(err)
+		}
 	}
 
 	b.ResetTimer()
@@ -50,17 +52,25 @@ func BenchmarkGetValidatorDelegations(b *testing.B) {
 
 	f, _, valAddrs, vals := initValidators(b, totalPower, len(powers), powers)
 	for _, validator := range vals {
-		f.stakingKeeper.SetValidator(f.sdkCtx, validator)
+		if err := f.stakingKeeper.SetValidator(f.sdkCtx, validator); err != nil {
+			panic(err)
+		}
 	}
 
 	delegationsNum := 1000
 	for _, val := range valAddrs {
 		for i := 0; i < delegationsNum; i++ {
 			delegator := sdk.AccAddress(fmt.Sprintf("address%d", i))
-			banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
+			err := banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
 				sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(int64(i)))))
+			if err != nil {
+				panic(err)
+			}
 			NewDel := types.NewDelegation(delegator, val, math.LegacyNewDec(int64(i)))
-			f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel)
+
+			if err := f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel); err != nil {
+				panic(err)
+			}
 		}
 	}
 
@@ -83,17 +93,24 @@ func BenchmarkGetValidatorDelegationsLegacy(b *testing.B) {
 	f, _, valAddrs, vals := initValidators(b, totalPower, len(powers), powers)
 
 	for _, validator := range vals {
-		f.stakingKeeper.SetValidator(f.sdkCtx, validator)
+		if err := f.stakingKeeper.SetValidator(f.sdkCtx, validator); err != nil {
+			panic(err)
+		}
 	}
 
 	delegationsNum := 1000
 	for _, val := range valAddrs {
 		for i := 0; i < delegationsNum; i++ {
 			delegator := sdk.AccAddress(fmt.Sprintf("address%d", i))
-			banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
+			err := banktestutil.FundAccount(f.sdkCtx, f.bankKeeper, delegator,
 				sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(int64(i)))))
+			if err != nil {
+				panic(err)
+			}
 			NewDel := types.NewDelegation(delegator, val, math.LegacyNewDec(int64(i)))
-			f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel)
+			if err := f.stakingKeeper.SetDelegation(f.sdkCtx, NewDel); err != nil {
+				panic(err)
+			}
 		}
 	}
 
@@ -115,9 +132,13 @@ func updateValidatorDelegationsLegacy(f *fixture, existingValAddr, newValAddr sd
 	for ; iterator.Valid(); iterator.Next() {
 		delegation := types.MustUnmarshalDelegation(cdc, iterator.Value())
 		if delegation.GetValidatorAddr().Equals(existingValAddr) {
-			k.RemoveDelegation(f.sdkCtx, delegation)
+			if err := k.RemoveDelegation(f.sdkCtx, delegation); err != nil {
+				panic(err)
+			}
 			delegation.ValidatorAddress = newValAddr.String()
-			k.SetDelegation(f.sdkCtx, delegation)
+			if err := k.SetDelegation(f.sdkCtx, delegation); err != nil {
+				panic(err)
+			}
 		}
 	}
 }
@@ -148,6 +169,9 @@ func updateValidatorDelegations(f *fixture, existingValAddr, newValAddr sdk.ValA
 
 		delegation.ValidatorAddress = newValAddr.String()
 		// add with new operator addr
-		k.SetDelegation(f.sdkCtx, delegation)
+		if err := k.SetDelegation(f.sdkCtx, delegation); err != nil {
+			panic(err)
+		}
+
 	}
 }
diff --git a/tests/integration/staking/keeper/validator_test.go b/tests/integration/staking/keeper/validator_test.go
index 2fb75e10ac6..11bdf082468 100644
--- a/tests/integration/staking/keeper/validator_test.go
+++ b/tests/integration/staking/keeper/validator_test.go
@@ -102,7 +102,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 
 	// remove enough tokens to kick out the validator below the current cliff
 	// validator and next in line cliff validator
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, nextCliffVal)
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, nextCliffVal))
 	shares := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 21)
 	nextCliffVal, _ = nextCliffVal.RemoveDelShares(math.LegacyNewDecFromInt(shares))
 	_ = keeper.TestingUpdateValidator(f.stakingKeeper, f.sdkCtx, nextCliffVal, true)
@@ -144,12 +144,13 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
 	validator, _ = validator.AddTokensFromDel(valTokens)
 	assert.Equal(t, types.Unbonded, validator.Status)
 	assert.DeepEqual(t, valTokens, validator.Tokens)
-	f.stakingKeeper.SetValidatorByConsAddr(f.sdkCtx, validator)
+	assert.NilError(t, f.stakingKeeper.SetValidatorByConsAddr(f.sdkCtx, validator))
 	validator = keeper.TestingUpdateValidator(f.stakingKeeper, f.sdkCtx, validator, true)
 	assert.DeepEqual(t, valTokens, validator.Tokens)
 
 	// slash the validator by 100%
-	f.stakingKeeper.Slash(f.sdkCtx, sdk.ConsAddress(PKs[0].Address()), 0, 100, math.LegacyOneDec())
+	_, err = f.stakingKeeper.Slash(f.sdkCtx, sdk.ConsAddress(PKs[0].Address()), 0, 100, math.LegacyOneDec())
+	assert.NilError(t, err)
 	// apply TM updates
 	applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, -1)
 	// validator should be unbonding
@@ -320,8 +321,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	assert.NilError(t, err)
 	nMax := uint32(2)
 	params.MaxValidators = nMax
-	f.stakingKeeper.SetParams(f.sdkCtx, params)
-
+	assert.NilError(t, f.stakingKeeper.SetParams(f.sdkCtx, params))
 	// initialize some validators into the state
 	powers := []int64{0, 100, 400, 400}
 	var validators [4]types.Validator
@@ -346,7 +346,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	assert.Assert(ValEq(t, validators[3], resValidators[1]))
 
 	// delegate 500 tokens to validator 0
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0]))
 	delTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 500)
 	validators[0], _ = validators[0].AddTokensFromDel(delTokens)
 	notBondedPool := f.stakingKeeper.GetNotBondedPool(f.sdkCtx)
@@ -380,7 +380,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 
 	validators[3], err = f.stakingKeeper.GetValidator(f.sdkCtx, validators[3].GetOperator())
 	assert.NilError(t, err)
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3]))
 	validators[3], _ = validators[3].AddTokensFromDel(f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 1))
 
 	notBondedPool = f.stakingKeeper.GetNotBondedPool(f.sdkCtx)
@@ -396,7 +396,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	assert.Assert(ValEq(t, validators[3], resValidators[1]))
 
 	// validator 3 kicked out temporarily
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3]))
 	rmTokens := validators[3].TokensFromShares(math.LegacyNewDec(201)).TruncateInt()
 	validators[3], _ = validators[3].RemoveDelShares(math.LegacyNewDec(201))
 
@@ -412,7 +412,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	assert.Assert(ValEq(t, validators[2], resValidators[1]))
 
 	// validator 3 does not get spot back
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[3]))
 	validators[3], _ = validators[3].AddTokensFromDel(math.NewInt(200))
 
 	notBondedPool = f.stakingKeeper.GetNotBondedPool(f.sdkCtx)
@@ -436,8 +436,7 @@ func TestValidatorBondHeight(t *testing.T) {
 	params, err := f.stakingKeeper.GetParams(f.sdkCtx)
 	assert.NilError(t, err)
 	params.MaxValidators = 2
-	f.stakingKeeper.SetParams(f.sdkCtx, params)
-
+	assert.NilError(t, f.stakingKeeper.SetParams(f.sdkCtx, params))
 	// initialize some validators into the state
 	var validators [3]types.Validator
 	validators[0] = testutil.NewValidator(t, sdk.ValAddress(PKs[0].Address().Bytes()), PKs[0])
@@ -465,8 +464,8 @@ func TestValidatorBondHeight(t *testing.T) {
 
 	assert.Assert(ValEq(t, validators[0], resValidators[0]))
 	assert.Assert(ValEq(t, validators[1], resValidators[1]))
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1])
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[2])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1]))
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[2]))
 	delTokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 50)
 	validators[1], _ = validators[1].AddTokensFromDel(delTokens)
 	validators[2], _ = validators[2].AddTokensFromDel(delTokens)
@@ -540,10 +539,10 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 	// test from nothing to something
 	//  tendermintUpdate set: {} -> {c1, c3}
 	applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 0)
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[0])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0])
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[1])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[0]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0]))
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[1]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1]))
 
 	updates := applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 2)
 	validators[0], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[0].GetOperator())
@@ -634,24 +633,24 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 
 	// test validtor added at the beginning
 	//  tendermintUpdate set: {} -> {c0}
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[2])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[2]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2]))
 	updates := applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
 	validators[2], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[2].GetOperator())
 	assert.DeepEqual(t, validators[2].ABCIValidatorUpdate(f.stakingKeeper.PowerReduction(f.sdkCtx)), updates[0])
 
 	// test validtor added at the beginning
 	//  tendermintUpdate set: {} -> {c0}
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[3])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[3])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[3]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[3]))
 	updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
 	validators[3], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[3].GetOperator())
 	assert.DeepEqual(t, validators[3].ABCIValidatorUpdate(f.stakingKeeper.PowerReduction(f.sdkCtx)), updates[0])
 
 	// test validtor added at the end
 	//  tendermintUpdate set: {} -> {c0}
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[4])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[4])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[4]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[4]))
 	updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
 	validators[4], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[4].GetOperator())
 	assert.DeepEqual(t, validators[4].ABCIValidatorUpdate(f.stakingKeeper.PowerReduction(f.sdkCtx)), updates[0])
@@ -661,8 +660,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	f, addrs, _ := bootstrapValidatorTest(t, 1000, 20)
 	params := types.DefaultParams()
 	params.MaxValidators = 2
-	f.stakingKeeper.SetParams(f.sdkCtx, params)
-
+	err := f.stakingKeeper.SetParams(f.sdkCtx, params)
+	assert.NilError(t, err)
 	powers := []int64{10, 20, 5}
 	var validators [5]types.Validator
 	for i, power := range powers {
@@ -685,8 +684,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 
 	tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 10)
 	validators[2], _ = validators[2].AddTokensFromDel(tokens)
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[2])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[2]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[2]))
 	updates := applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 2)
 	validators[2], _ = f.stakingKeeper.GetValidator(f.sdkCtx, validators[2].GetOperator())
 	assert.DeepEqual(t, validators[0].ABCIValidatorUpdateZero(), updates[1])
@@ -713,8 +712,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 		tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
-		f.stakingKeeper.SetValidator(f.sdkCtx, validators[i])
-		f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i])
+		assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[i]))
+		assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i]))
 	}
 
 	// verify initial CometBFT updates are correct
@@ -729,12 +728,12 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	// update initial validator set
 	for i, power := range powers {
 
-		f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[i])
+		assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[i]))
 		tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
-		f.stakingKeeper.SetValidator(f.sdkCtx, validators[i])
-		f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i])
+		assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[i]))
+		assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i]))
 	}
 
 	// add a new validator that goes from zero power, to non-zero power, back to
@@ -746,11 +745,11 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	validator := testutil.NewValidator(t, valAddr, valPubKey)
 	validator, _ = validator.AddTokensFromDel(amt)
 
-	f.stakingKeeper.SetValidator(f.sdkCtx, validator)
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validator))
 
 	validator, _ = validator.RemoveDelShares(math.LegacyNewDecFromInt(amt))
-	f.stakingKeeper.SetValidator(f.sdkCtx, validator)
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator)
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validator))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator))
 
 	// add a new validator that increases in power
 	valPubKey = PKs[len(validators)+2]
@@ -759,8 +758,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	validator = testutil.NewValidator(t, valAddr, valPubKey)
 	tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 500)
 	validator, _ = validator.AddTokensFromDel(tokens)
-	f.stakingKeeper.SetValidator(f.sdkCtx, validator)
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator)
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validator))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validator))
 
 	// verify initial CometBFT updates are correct
 	updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, len(validators)+1)
@@ -792,8 +791,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 		validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker)
 		tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
-		f.stakingKeeper.SetValidator(f.sdkCtx, validators[i])
-		f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i])
+		assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[i]))
+		assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[i]))
 	}
 
 	// verify initial CometBFT updates are correct
@@ -811,11 +810,11 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	validators[0], err = f.stakingKeeper.GetValidator(f.sdkCtx, validators[0].GetOperator())
 	assert.NilError(t, err)
 
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0]))
 	tokens := f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 1)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens)
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[0])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[0]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0]))
 
 	// verify initial CometBFT updates are correct
 	applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 0)
@@ -827,17 +826,17 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	validators[1], err = f.stakingKeeper.GetValidator(f.sdkCtx, validators[1].GetOperator())
 	assert.NilError(t, err)
 
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[0]))
 	validators[0], _ = validators[0].RemoveDelShares(validators[0].DelegatorShares)
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[0])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[0]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[0]))
 	applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 0)
 
-	f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1])
+	assert.NilError(t, f.stakingKeeper.DeleteValidatorByPowerIndex(f.sdkCtx, validators[1]))
 	tokens = f.stakingKeeper.TokensFromConsensusPower(f.sdkCtx, 250)
 	validators[1], _ = validators[1].AddTokensFromDel(tokens)
-	f.stakingKeeper.SetValidator(f.sdkCtx, validators[1])
-	f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1])
+	assert.NilError(t, f.stakingKeeper.SetValidator(f.sdkCtx, validators[1]))
+	assert.NilError(t, f.stakingKeeper.SetValidatorByPowerIndex(f.sdkCtx, validators[1]))
 
 	// verify initial CometBFT updates are correct
 	updates = applyValidatorSetUpdates(t, f.sdkCtx, f.stakingKeeper, 1)
diff --git a/tests/integration/staking/simulation/operations_test.go b/tests/integration/staking/simulation/operations_test.go
index 8f0546062ba..7e97aa863fb 100644
--- a/tests/integration/staking/simulation/operations_test.go
+++ b/tests/integration/staking/simulation/operations_test.go
@@ -165,7 +165,6 @@ func (s *SimTestSuite) TestSimulateMsgCreateValidator() {
 	require := s.Require()
 	_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash})
 	require.NoError(err)
-
 	// execute operation
 	op := simulation.SimulateMsgCreateValidator(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
 	operationMsg, futureOperations, err := op(s.r, s.app.BaseApp, s.ctx, s.accounts[1:], "")
@@ -210,7 +209,6 @@ func (s *SimTestSuite) TestSimulateMsgCancelUnbondingDelegation() {
 
 	_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash, Time: blockTime})
 	require.NoError(err)
-
 	// execute operation
 	op := simulation.SimulateMsgCancelUnbondingDelegate(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
 	accounts := []simtypes.Account{delegator}
@@ -239,7 +237,6 @@ func (s *SimTestSuite) TestSimulateMsgEditValidator() {
 
 	_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash, Time: blockTime})
 	require.NoError(err)
-
 	// execute operation
 	op := simulation.SimulateMsgEditValidator(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
 	operationMsg, futureOperations, err := op(s.r, s.app.BaseApp, ctx, s.accounts, "")
@@ -299,7 +296,6 @@ func (s *SimTestSuite) TestSimulateMsgUndelegate() {
 
 	_, err := s.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: s.app.LastBlockHeight() + 1, Hash: s.app.LastCommitID().Hash, Time: blockTime})
 	require.NoError(err)
-
 	// execute operation
 	op := simulation.SimulateMsgUndelegate(s.txConfig, s.accountKeeper, s.bankKeeper, s.stakingKeeper)
 	operationMsg, futureOperations, err := op(s.r, s.app.BaseApp, ctx, s.accounts, "")
diff --git a/tests/integration/store/rootmulti/rollback_test.go b/tests/integration/store/rootmulti/rollback_test.go
index 9e4454bdcb1..60303fdee99 100644
--- a/tests/integration/store/rootmulti/rollback_test.go
+++ b/tests/integration/store/rootmulti/rollback_test.go
@@ -31,16 +31,19 @@ func TestRollback(t *testing.T) {
 			AppHash: app.LastCommitID().Hash,
 		}
 
-		app.FinalizeBlock(&abci.RequestFinalizeBlock{
+		_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 			Height: header.Height,
 		})
+		assert.NilError(t, err)
 		ctx := app.NewContextLegacy(false, header)
 		store := ctx.KVStore(app.GetKey("bank"))
 		store.Set([]byte("key"), []byte(fmt.Sprintf("value%d", i)))
-		app.FinalizeBlock(&abci.RequestFinalizeBlock{
+		_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 			Height: header.Height,
 		})
-		app.Commit()
+		assert.NilError(t, err)
+		_, err = app.Commit()
+		assert.NilError(t, err)
 	}
 
 	assert.Equal(t, ver0+10, app.LastBlockHeight())
@@ -63,14 +66,17 @@ func TestRollback(t *testing.T) {
 			Height:  ver0 + i,
 			AppHash: app.LastCommitID().Hash,
 		}
-		app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: header.Height})
+		_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: header.Height})
+		assert.NilError(t, err)
 		ctx := app.NewContextLegacy(false, header)
 		store := ctx.KVStore(app.GetKey("bank"))
 		store.Set([]byte("key"), []byte(fmt.Sprintf("VALUE%d", i)))
-		app.FinalizeBlock(&abci.RequestFinalizeBlock{
+		_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 			Height: header.Height,
 		})
-		app.Commit()
+		assert.NilError(t, err)
+		_, err = app.Commit()
+		assert.NilError(t, err)
 	}
 
 	assert.Equal(t, ver0+10, app.LastBlockHeight())
diff --git a/testutil/integration/router.go b/testutil/integration/router.go
index 4270d493ad8..719575bcd65 100644
--- a/testutil/integration/router.go
+++ b/testutil/integration/router.go
@@ -102,7 +102,10 @@ func NewIntegrationApp(
 		}
 	}
 
-	bApp.Commit()
+	_, err := bApp.Commit()
+	if err != nil {
+		panic(err)
+	}
 
 	ctx := sdkCtx.WithBlockHeader(cmtproto.Header{ChainID: appName}).WithIsCheckTx(true)
 
@@ -129,7 +132,12 @@ func (app *App) RunMsg(msg sdk.Msg, option ...Option) (*codectypes.Any, error) {
 	}
 
 	if cfg.AutomaticCommit {
-		defer app.Commit()
+		defer func() {
+			_, err := app.Commit()
+			if err != nil {
+				panic(err)
+			}
+		}()
 	}
 
 	if cfg.AutomaticFinalizeBlock {
diff --git a/testutil/network/network.go b/testutil/network/network.go
index 4527fbc9313..83758639806 100644
--- a/testutil/network/network.go
+++ b/testutil/network/network.go
@@ -744,7 +744,7 @@ func (n *Network) WaitForHeightWithTimeout(h int64, t time.Duration) (int64, err
 // blocks has been reached.
 func (n *Network) RetryForBlocks(retryFunc func() error, blocks int) error {
 	for i := 0; i < blocks; i++ {
-		n.WaitForNextBlock()
+		_ = n.WaitForNextBlock()
 		err := retryFunc()
 		if err == nil {
 			return nil
diff --git a/testutil/sims/simulation_helpers_test.go b/testutil/sims/simulation_helpers_test.go
index e9c6c31dc10..349c5535c42 100644
--- a/testutil/sims/simulation_helpers_test.go
+++ b/testutil/sims/simulation_helpers_test.go
@@ -118,6 +118,8 @@ func initTestStores(t *testing.T) (storetypes.KVStore, storetypes.KVStore) {
 	key2 := storetypes.NewKVStoreKey("store2")
 	require.NotPanics(t, func() { ms.MountStoreWithDB(key1, storetypes.StoreTypeIAVL, db) })
 	require.NotPanics(t, func() { ms.MountStoreWithDB(key2, storetypes.StoreTypeIAVL, db) })
-	require.NotPanics(t, func() { ms.LoadLatestVersion() })
+	require.NotPanics(t, func() {
+		_ = ms.LoadLatestVersion()
+	})
 	return ms.GetKVStore(key1), ms.GetKVStore(key2)
 }
diff --git a/testutil/sims/tx_helpers.go b/testutil/sims/tx_helpers.go
index 9c8244c347d..f334925bcec 100644
--- a/testutil/sims/tx_helpers.go
+++ b/testutil/sims/tx_helpers.go
@@ -141,8 +141,8 @@ func SignCheckDeliver(
 		require.False(t, finalizeSuccess)
 	}
 
-	app.Commit()
-
+	_, err = app.Commit()
+	require.NoError(t, err)
 	gInfo := sdk.GasInfo{GasWanted: uint64(txResult.GasWanted), GasUsed: uint64(txResult.GasUsed)}
 	txRes := sdk.Result{Data: txResult.Data, Log: txResult.Log, Events: txResult.Events}
 	if finalizeSuccess {
diff --git a/tools/rosetta/lib/errors/errors_test.go b/tools/rosetta/lib/errors/errors_test.go
index 9782c654db6..c4ea5348fcb 100644
--- a/tools/rosetta/lib/errors/errors_test.go
+++ b/tools/rosetta/lib/errors/errors_test.go
@@ -20,7 +20,7 @@ func TestRegisterError(t *testing.T) {
 	registeredErrorsCount++
 	assert.Equal(t, len(ListErrors()), registeredErrorsCount)
 	// re-register an error should not change anything
-	RegisterError(69, "nice!", false, "nice!")
+	_ = RegisterError(69, "nice!", false, "nice!")
 	assert.Equal(t, len(ListErrors()), registeredErrorsCount)
 
 	// test sealing
diff --git a/types/address_test.go b/types/address_test.go
index 4cded9e20e1..8473047c173 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -92,8 +92,8 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 	pub := &ed25519.PubKey{Key: pubBz}
 
 	for i := 0; i < 1000; i++ {
-		rand.Read(pub.Key)
-
+		_, err := rand.Read(pub.Key)
+		s.Require().NoError(err)
 		acc := types.AccAddress(pub.Address())
 		res := types.AccAddress{}
 
@@ -101,7 +101,7 @@ func (s *addressTestSuite) TestRandBech32AccAddrConsistency() {
 		s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal)
 
 		str := acc.String()
-		res, err := types.AccAddressFromBech32(str)
+		res, err = types.AccAddressFromBech32(str)
 		s.Require().Nil(err)
 		s.Require().Equal(acc, res)
 
@@ -133,8 +133,8 @@ func (s *addressTestSuite) TestAddrCache() {
 	// Use a random key
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
-	rand.Read(pub.Key)
-
+	_, err := rand.Read(pub.Key)
+	s.Require().NoError(err)
 	// Set SDK bech32 prefixes to 'osmo'
 	prefix := "osmo"
 	conf := types.GetConfig()
@@ -170,8 +170,8 @@ func (s *addressTestSuite) TestAddrCacheDisabled() {
 	// Use a random key
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
-	rand.Read(pub.Key)
-
+	_, err := rand.Read(pub.Key)
+	s.Require().NoError(err)
 	// Set SDK bech32 prefixes to 'osmo'
 	prefix := "osmo"
 	conf := types.GetConfig()
@@ -202,8 +202,8 @@ func (s *addressTestSuite) TestValAddr() {
 	pub := &ed25519.PubKey{Key: pubBz}
 
 	for i := 0; i < 20; i++ {
-		rand.Read(pub.Key)
-
+		_, err := rand.Read(pub.Key)
+		s.Require().NoError(err)
 		acc := types.ValAddress(pub.Address())
 		res := types.ValAddress{}
 
@@ -211,7 +211,7 @@ func (s *addressTestSuite) TestValAddr() {
 		s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal)
 
 		str := acc.String()
-		res, err := types.ValAddressFromBech32(str)
+		res, err = types.ValAddressFromBech32(str)
 		s.Require().Nil(err)
 		s.Require().Equal(acc, res)
 
@@ -243,8 +243,8 @@ func (s *addressTestSuite) TestConsAddress() {
 	pub := &ed25519.PubKey{Key: pubBz}
 
 	for i := 0; i < 20; i++ {
-		rand.Read(pub.Key[:])
-
+		_, err := rand.Read(pub.Key[:])
+		s.Require().NoError(err)
 		acc := types.ConsAddress(pub.Address())
 		res := types.ConsAddress{}
 
@@ -252,7 +252,7 @@ func (s *addressTestSuite) TestConsAddress() {
 		s.testMarshal(&acc, &res, acc.Marshal, (&res).Unmarshal)
 
 		str := acc.String()
-		res, err := types.ConsAddressFromBech32(str)
+		res, err = types.ConsAddressFromBech32(str)
 		s.Require().Nil(err)
 		s.Require().Equal(acc, res)
 
@@ -293,7 +293,8 @@ func (s *addressTestSuite) TestConfiguredPrefix() {
 	pub := &ed25519.PubKey{Key: pubBz}
 	for length := 1; length < 10; length++ {
 		for times := 1; times < 20; times++ {
-			rand.Read(pub.Key[:])
+			_, err := rand.Read(pub.Key[:])
+			s.Require().NoError(err)
 			// Test if randomly generated prefix of a given length works
 			prefix := RandString(length)
 
@@ -347,8 +348,8 @@ func (s *addressTestSuite) TestConfiguredPrefix() {
 func (s *addressTestSuite) TestAddressInterface() {
 	pubBz := make([]byte, ed25519.PubKeySize)
 	pub := &ed25519.PubKey{Key: pubBz}
-	rand.Read(pub.Key)
-
+	_, err := rand.Read(pub.Key)
+	s.Require().NoError(err)
 	addrs := []types.Address{
 		types.ConsAddress(pub.Address()),
 		types.ValAddress(pub.Address()),
diff --git a/types/module/module_test.go b/types/module/module_test.go
index 3cde79f6a6f..a87a37b28af 100644
--- a/types/module/module_test.go
+++ b/types/module/module_test.go
@@ -219,7 +219,12 @@ func TestManager_RegisterQueryServices(t *testing.T) {
 	mockAppModule1.EXPECT().RegisterServices(cfg).Times(1)
 	mockAppModule2.EXPECT().RegisterServices(cfg).Times(1)
 
-	require.NotPanics(t, func() { mm.RegisterServices(cfg) })
+	require.NotPanics(t, func() {
+		err := mm.RegisterServices(cfg)
+		if err != nil {
+			panic(err)
+		}
+	})
 }
 
 func TestManager_InitGenesis(t *testing.T) {
@@ -575,7 +580,10 @@ func (MockCoreAppModule) DefaultGenesis(target appmodule.GenesisTarget) error {
 	if err != nil {
 		return err
 	}
-	someFieldWriter.Write([]byte(`"someKey"`))
+	_, err = someFieldWriter.Write([]byte(`"someKey"`))
+	if err != nil {
+		return err
+	}
 	return someFieldWriter.Close()
 }
 
@@ -602,7 +610,10 @@ func (MockCoreAppModule) ExportGenesis(ctx context.Context, target appmodule.Gen
 	if err != nil {
 		return err
 	}
-	wrt.Write([]byte(`"someKey"`))
+	_, err = wrt.Write([]byte(`"someKey"`))
+	if err != nil {
+		return err
+	}
 	return wrt.Close()
 }
 
diff --git a/x/auth/ante/ante_test.go b/x/auth/ante/ante_test.go
index 8c7be921954..be1948ae97a 100644
--- a/x/auth/ante/ante_test.go
+++ b/x/auth/ante/ante_test.go
@@ -1086,7 +1086,8 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
 
 				privs, accNums, accSeqs := []cryptotypes.PrivKey{accs[1].priv}, []uint64{accs[1].acc.GetAccountNumber()}, []uint64{accs[1].acc.GetSequence()}
 				msgs := []sdk.Msg{testdata.NewTestMsg(accs[1].acc.GetAddress())}
-				suite.txBuilder.SetMsgs(msgs...)
+				err := suite.txBuilder.SetMsgs(msgs...)
+				require.NoError(t, err)
 				suite.txBuilder.SetFeeAmount(feeAmount)
 				suite.txBuilder.SetGasLimit(gasLimit)
 
@@ -1132,7 +1133,8 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
 
 				privs, accNums, accSeqs := []cryptotypes.PrivKey{accs[1].priv}, []uint64{accs[1].acc.GetAccountNumber()}, []uint64{accs[1].acc.GetSequence()}
 				msgs := []sdk.Msg{testdata.NewTestMsg(accs[1].acc.GetAddress())}
-				suite.txBuilder.SetMsgs(msgs...)
+				err := suite.txBuilder.SetMsgs(msgs...)
+				require.NoError(t, err)
 				suite.txBuilder.SetFeeAmount(feeAmount)
 				suite.txBuilder.SetGasLimit(gasLimit)
 
diff --git a/x/auth/ante/setup_test.go b/x/auth/ante/setup_test.go
index e806a9b2448..c9fa03b461a 100644
--- a/x/auth/ante/setup_test.go
+++ b/x/auth/ante/setup_test.go
@@ -118,7 +118,7 @@ func TestRecoverPanic(t *testing.T) {
 	require.Equal(t, gasLimit, newCtx.GasMeter().Limit())
 
 	antehandler = sdk.ChainAnteDecorators(sud, PanicDecorator{})
-	require.Panics(t, func() { antehandler(suite.ctx, tx, false) }, "Recovered from non-Out-of-Gas panic")
+	require.Panics(t, func() { _, _ = antehandler(suite.ctx, tx, false) }, "Recovered from non-Out-of-Gas panic")
 }
 
 type OutOfGasDecorator struct{}
diff --git a/x/auth/ante/sigverify_test.go b/x/auth/ante/sigverify_test.go
index d61dd2a2441..45049aaedf0 100644
--- a/x/auth/ante/sigverify_test.go
+++ b/x/auth/ante/sigverify_test.go
@@ -226,7 +226,9 @@ func TestSigVerification(t *testing.T) {
 						},
 						Sequence: tc.accSeqs[0],
 					}
-					suite.txBuilder.SetSignatures(txSigs...)
+					err := suite.txBuilder.SetSignatures(txSigs...)
+					require.NoError(t, err)
+
 					tx = suite.txBuilder.GetTx()
 				}
 
diff --git a/x/auth/ante/testutil_test.go b/x/auth/ante/testutil_test.go
index 022ded1b282..2d597f37b4f 100644
--- a/x/auth/ante/testutil_test.go
+++ b/x/auth/ante/testutil_test.go
@@ -117,7 +117,10 @@ func (suite *AnteTestSuite) CreateTestAccounts(numAccs int) []TestAccount {
 	for i := 0; i < numAccs; i++ {
 		priv, _, addr := testdata.KeyTestPubAddr()
 		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, addr)
-		acc.SetAccountNumber(uint64(i + 1000))
+		err := acc.SetAccountNumber(uint64(i + 1000))
+		if err != nil {
+			panic(err)
+		}
 		suite.accountKeeper.SetAccount(suite.ctx, acc)
 		accounts = append(accounts, TestAccount{acc, priv})
 	}
diff --git a/x/auth/client/cli/tx_sign.go b/x/auth/client/cli/tx_sign.go
index ec149167bb0..7ba332e3579 100644
--- a/x/auth/client/cli/tx_sign.go
+++ b/x/auth/client/cli/tx_sign.go
@@ -58,7 +58,10 @@ account key. It implies --signature-only.
 
 	flags.AddTxFlagsToCmd(cmd)
 
-	cmd.MarkFlagRequired(flags.FlagFrom)
+	err := cmd.MarkFlagRequired(flags.FlagFrom)
+	if err != nil {
+		panic(err)
+	}
 
 	return cmd
 }
@@ -137,7 +140,10 @@ func makeSignBatchCmd() func(cmd *cobra.Command, args []string) error {
 				msgs = append(msgs, unsignedStdTx.GetMsgs()...)
 			}
 			// set the new appened msgs into builder
-			txBuilder.SetMsgs(msgs...)
+			err = txBuilder.SetMsgs(msgs...)
+			if err != nil {
+				return err
+			}
 
 			// set the memo,fees,feeGranter,feePayer from cmd flags
 			txBuilder.SetMemo(txFactory.Memo())
@@ -284,7 +290,10 @@ be generated via the 'multisign' command.
 	cmd.Flags().String(flags.FlagOutputDocument, "", "The document will be written to the given file instead of STDOUT")
 	flags.AddTxFlagsToCmd(cmd)
 
-	cmd.MarkFlagRequired(flags.FlagFrom)
+	err := cmd.MarkFlagRequired(flags.FlagFrom)
+	if err != nil {
+		panic(err)
+	}
 
 	return cmd
 }
@@ -293,8 +302,14 @@ func preSignCmd(cmd *cobra.Command, _ []string) {
 	// Conditionally mark the account and sequence numbers required as no RPC
 	// query will be done.
 	if offline, _ := cmd.Flags().GetBool(flags.FlagOffline); offline {
-		cmd.MarkFlagRequired(flags.FlagAccountNumber)
-		cmd.MarkFlagRequired(flags.FlagSequence)
+		err := cmd.MarkFlagRequired(flags.FlagAccountNumber)
+		if err != nil {
+			panic(err)
+		}
+		err = cmd.MarkFlagRequired(flags.FlagSequence)
+		if err != nil {
+			panic(err)
+		}
 	}
 }
 
diff --git a/x/auth/migrations/v3/store.go b/x/auth/migrations/v3/store.go
index 62deba2e49b..fb21be8e0cd 100644
--- a/x/auth/migrations/v3/store.go
+++ b/x/auth/migrations/v3/store.go
@@ -22,7 +22,10 @@ func mapAccountAddressToAccountID(ctx sdk.Context, storeService corestore.KVStor
 		if err := cdc.UnmarshalInterface(iterator.Value(), &acc); err != nil {
 			return err
 		}
-		store.Set(accountNumberStoreKey(acc.GetAccountNumber()), acc.GetAddress().Bytes())
+		err = store.Set(accountNumberStoreKey(acc.GetAccountNumber()), acc.GetAddress().Bytes())
+		if err != nil {
+			return err
+		}
 	}
 
 	return nil
diff --git a/x/auth/migrations/v4/migrate.go b/x/auth/migrations/v4/migrate.go
index 3372b248c6f..493aba3254a 100644
--- a/x/auth/migrations/v4/migrate.go
+++ b/x/auth/migrations/v4/migrate.go
@@ -25,7 +25,5 @@ func Migrate(ctx sdk.Context, storeService storetypes.KVStoreService, legacySubs
 	}
 
 	bz := cdc.MustMarshal(&currParams)
-	store.Set(ParamsKey, bz)
-
-	return nil
+	return store.Set(ParamsKey, bz)
 }
diff --git a/x/auth/tx/aux_test.go b/x/auth/tx/aux_test.go
index 70c5ce5c857..2a5e63a5053 100644
--- a/x/auth/tx/aux_test.go
+++ b/x/auth/tx/aux_test.go
@@ -59,8 +59,10 @@ func TestBuilderWithAux(t *testing.T) {
 	aux2Builder.SetTimeoutHeight(3)
 	aux2Builder.SetMemo(memo)
 	aux2Builder.SetChainID(chainID)
-	aux2Builder.SetMsgs(msg)
-	aux2Builder.SetPubKey(aux2Pk)
+	err = aux2Builder.SetMsgs(msg)
+	require.NoError(t, err)
+	err = aux2Builder.SetPubKey(aux2Pk)
+	require.NoError(t, err)
 	aux2Builder.SetTip(tip)
 	extOptAny, err := codectypes.NewAnyWithValue(extOpt)
 	require.NoError(t, err)
@@ -130,10 +132,12 @@ func TestBuilderWithAux(t *testing.T) {
 	tipperSigV2 := sigs[0]
 	aux2SigV2 := sigs[1]
 	// Set all signer infos.
-	w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
+	err = w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
 		PubKey:   feepayerPk,
 		Sequence: 15,
 	})
+	require.NoError(t, err)
+
 	signerData := authsigning.SignerData{
 		Address:       feepayerAddr.String(),
 		ChainID:       chainID,
@@ -150,7 +154,7 @@ func TestBuilderWithAux(t *testing.T) {
 	feepayerSig, err := feepayerPriv.Sign(signBz)
 	require.NoError(t, err)
 	// Set all signatures.
-	w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
+	err = w.SetSignatures(tipperSigV2, aux2SigV2, signing.SignatureV2{
 		PubKey: feepayerPk,
 		Data: &signing.SingleSignatureData{
 			SignMode:  signing.SignMode_SIGN_MODE_DIRECT,
@@ -158,6 +162,7 @@ func TestBuilderWithAux(t *testing.T) {
 		},
 		Sequence: 22,
 	})
+	require.NoError(t, err)
 
 	// Make sure tx is correct.
 	txBz, err := txConfig.TxEncoder()(w.GetTx())
@@ -200,8 +205,10 @@ func makeTipperTxBuilder(t *testing.T) (clienttx.AuxTxBuilder, []byte) {
 	tipperBuilder.SetTimeoutHeight(3)
 	tipperBuilder.SetMemo(memo)
 	tipperBuilder.SetChainID(chainID)
-	tipperBuilder.SetMsgs(msg)
-	tipperBuilder.SetPubKey(tipperPk)
+	err := tipperBuilder.SetMsgs(msg)
+	require.NoError(t, err)
+	err = tipperBuilder.SetPubKey(tipperPk)
+	require.NoError(t, err)
 	tipperBuilder.SetTip(tip)
 	extOptAny, err := codectypes.NewAnyWithValue(extOpt)
 	require.NoError(t, err)
diff --git a/x/auth/tx/service.go b/x/auth/tx/service.go
index 9f4d56a9316..0113f34b3c6 100644
--- a/x/auth/tx/service.go
+++ b/x/auth/tx/service.go
@@ -320,7 +320,10 @@ func RegisterTxService(
 // RegisterGRPCGatewayRoutes mounts the tx service's GRPC-gateway routes on the
 // given Mux.
 func RegisterGRPCGatewayRoutes(clientConn gogogrpc.ClientConn, mux *runtime.ServeMux) {
-	txtypes.RegisterServiceHandlerClient(context.Background(), mux, txtypes.NewServiceClient(clientConn))
+	err := txtypes.RegisterServiceHandlerClient(context.Background(), mux, txtypes.NewServiceClient(clientConn))
+	if err != nil {
+		panic(err)
+	}
 }
 
 func parseOrderBy(orderBy txtypes.OrderBy) string {
diff --git a/x/auth/types/account_test.go b/x/auth/types/account_test.go
index d29372dcd08..b4fadfa391a 100644
--- a/x/auth/types/account_test.go
+++ b/x/auth/types/account_test.go
@@ -97,7 +97,8 @@ func TestModuleAccountString(t *testing.T) {
 	moduleAcc := types.NewEmptyModuleAccount(name, types.Minter, types.Burner, types.Staking)
 	want := `base_account:<address:"cosmos1n7rdpqvgf37ktx30a2sv2kkszk3m7ncmg5drhe" > name:"test" permissions:"minter" permissions:"burner" permissions:"staking" `
 	require.Equal(t, want, moduleAcc.String())
-	moduleAcc.SetSequence(10)
+	err := moduleAcc.SetSequence(10)
+	require.NoError(t, err)
 	want = `base_account:<address:"cosmos1n7rdpqvgf37ktx30a2sv2kkszk3m7ncmg5drhe" sequence:10 > name:"test" permissions:"minter" permissions:"burner" permissions:"staking" `
 	require.Equal(t, want, moduleAcc.String())
 }
diff --git a/x/authz/client/cli/tx_test.go b/x/authz/client/cli/tx_test.go
index 62dd9550689..5cdda9401bb 100644
--- a/x/authz/client/cli/tx_test.go
+++ b/x/authz/client/cli/tx_test.go
@@ -174,7 +174,9 @@ func (s *CLITestSuite) createAccount(uid string) sdk.AccAddress {
 func (s *CLITestSuite) msgSendExec(grantee sdk.AccAddress) {
 	val := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
 	// Send some funds to the new account.
-	s.ac.StringToBytes("cosmos16zex22087zs656t0vedytv5wqhm6axxd5679ry")
+	_, err := s.ac.StringToBytes("cosmos16zex22087zs656t0vedytv5wqhm6axxd5679ry")
+	s.Require().NoError(err)
+
 	out, err := clitestutil.MsgSendExec(
 		s.clientCtx,
 		val[0].Address,
diff --git a/x/authz/keeper/genesis_test.go b/x/authz/keeper/genesis_test.go
index 94320f0ff65..03d5aa5729d 100644
--- a/x/authz/keeper/genesis_test.go
+++ b/x/authz/keeper/genesis_test.go
@@ -82,7 +82,8 @@ func (suite *GenesisTestSuite) TestImportExportGenesis() {
 
 	// TODO, recheck!
 	// Clear keeper
-	suite.keeper.DeleteGrant(suite.ctx, granteeAddr, granterAddr, grant.MsgTypeURL())
+	err = suite.keeper.DeleteGrant(suite.ctx, granteeAddr, granterAddr, grant.MsgTypeURL())
+	suite.Require().NoError(err)
 	newGenesis := suite.keeper.ExportGenesis(suite.ctx)
 	suite.Require().NotEqual(genesis, newGenesis)
 	suite.Require().Empty(newGenesis)
diff --git a/x/authz/keeper/keeper.go b/x/authz/keeper/keeper.go
index 39649ef4ea1..d88de2f5048 100644
--- a/x/authz/keeper/keeper.go
+++ b/x/authz/keeper/keeper.go
@@ -87,9 +87,7 @@ func (k Keeper) update(ctx context.Context, grantee, granter sdk.AccAddress, upd
 
 	grant.Authorization = any
 	store := k.storeService.OpenKVStore(ctx)
-	store.Set(skey, k.cdc.MustMarshal(&grant))
-
-	return nil
+	return store.Set(skey, k.cdc.MustMarshal(&grant))
 }
 
 // DispatchActions attempts to execute the provided messages via authorization
diff --git a/x/authz/keeper/keeper_test.go b/x/authz/keeper/keeper_test.go
index 165a47d4882..b8a53114f6b 100644
--- a/x/authz/keeper/keeper_test.go
+++ b/x/authz/keeper/keeper_test.go
@@ -148,8 +148,11 @@ func (s *TestSuite) TestKeeperIter() {
 	e := ctx.BlockTime().AddDate(1, 0, 0)
 	sendAuthz := banktypes.NewSendAuthorization(coins100, nil)
 
-	s.authzKeeper.SaveGrant(ctx, granteeAddr, granterAddr, sendAuthz, &e)
-	s.authzKeeper.SaveGrant(ctx, granteeAddr, granter2Addr, sendAuthz, &e)
+	err := s.authzKeeper.SaveGrant(ctx, granteeAddr, granterAddr, sendAuthz, &e)
+	s.Require().NoError(err)
+
+	err = s.authzKeeper.SaveGrant(ctx, granteeAddr, granter2Addr, sendAuthz, &e)
+	s.Require().NoError(err)
 
 	s.authzKeeper.IterateGrants(ctx, func(granter, grantee sdk.AccAddress, grant authz.Grant) bool {
 		s.Require().Equal(granteeAddr, grantee)
@@ -189,7 +192,8 @@ func (s *TestSuite) TestDispatchAction() {
 			"authorization not found",
 			func() sdk.Context {
 				// remove any existing authorizations
-				s.authzKeeper.DeleteGrant(s.ctx, granteeAddr, granterAddr, bankSendAuthMsgType)
+				err := s.authzKeeper.DeleteGrant(s.ctx, granteeAddr, granterAddr, bankSendAuthMsgType)
+				require.Error(err)
 				return s.ctx
 			},
 			func() {},
diff --git a/x/authz/migrations/v2/store_test.go b/x/authz/migrations/v2/store_test.go
index cf71c4519ea..e60a326a266 100644
--- a/x/authz/migrations/v2/store_test.go
+++ b/x/authz/migrations/v2/store_test.go
@@ -106,7 +106,8 @@ func TestMigration(t *testing.T) {
 
 	for _, g := range grants {
 		grant := g.authorization()
-		store.Set(v2.GrantStoreKey(g.grantee, g.granter, g.msgType), cdc.MustMarshal(&grant))
+		err := store.Set(v2.GrantStoreKey(g.grantee, g.granter, g.msgType), cdc.MustMarshal(&grant))
+		require.NoError(t, err)
 	}
 
 	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(1 * time.Hour))
diff --git a/x/authz/module/abci_test.go b/x/authz/module/abci_test.go
index 12055e0cfa1..5cccdc1526b 100644
--- a/x/authz/module/abci_test.go
+++ b/x/authz/module/abci_test.go
@@ -81,7 +81,8 @@ func TestExpiredGrantsQueue(t *testing.T) {
 	queryClient := authz.NewQueryClient(queryHelper)
 
 	checkGrants := func(ctx sdk.Context, expectedNum int) {
-		authzmodule.BeginBlocker(ctx, authzKeeper)
+		err := authzmodule.BeginBlocker(ctx, authzKeeper)
+		require.NoError(t, err)
 
 		res, err := queryClient.GranterGrants(ctx.Context(), &authz.QueryGranterGrantsRequest{
 			Granter: granter.String(),
diff --git a/x/authz/msgs_test.go b/x/authz/msgs_test.go
index a3075002c88..d460f191f90 100644
--- a/x/authz/msgs_test.go
+++ b/x/authz/msgs_test.go
@@ -40,7 +40,9 @@ func TestMsgGrantGetAuthorization(t *testing.T) {
 	require.Equal(a, &g)
 
 	g = authz.GenericAuthorization{Msg: "some_type2"}
-	m.SetAuthorization(&g)
+	err = m.SetAuthorization(&g)
+	require.NoError(err)
+
 	a, err = m.GetAuthorization()
 	require.NoError(err)
 	require.Equal(a, &g)
diff --git a/x/authz/simulation/operations_test.go b/x/authz/simulation/operations_test.go
index 8a6894dc2b0..fda4c37c031 100644
--- a/x/authz/simulation/operations_test.go
+++ b/x/authz/simulation/operations_test.go
@@ -122,11 +122,11 @@ func (suite *SimTestSuite) TestSimulateGrant() {
 	blockTime := time.Now().UTC()
 	ctx := suite.ctx.WithBlockTime(blockTime)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
-
+	suite.Require().NoError(err)
 	granter := accounts[0]
 	grantee := accounts[1]
 
@@ -150,11 +150,11 @@ func (suite *SimTestSuite) TestSimulateRevoke() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, 3)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
-
+	suite.Require().NoError(err)
 	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
 
@@ -163,7 +163,7 @@ func (suite *SimTestSuite) TestSimulateRevoke() {
 	a := banktypes.NewSendAuthorization(initCoins, nil)
 	expire := time.Now().Add(30 * time.Hour)
 
-	err := suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
+	err = suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
 	suite.Require().NoError(err)
 
 	// execute operation
@@ -187,8 +187,8 @@ func (suite *SimTestSuite) TestSimulateExec() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, 3)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
-
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
+	suite.Require().NoError(err)
 	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
 
@@ -197,7 +197,7 @@ func (suite *SimTestSuite) TestSimulateExec() {
 	a := banktypes.NewSendAuthorization(initCoins, nil)
 	expire := suite.ctx.BlockTime().Add(1 * time.Hour)
 
-	err := suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
+	err = suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
 	suite.Require().NoError(err)
 
 	// execute operation
diff --git a/x/bank/client/cli/tx.go b/x/bank/client/cli/tx.go
index 151190dd7ed..ddb3527f3b2 100644
--- a/x/bank/client/cli/tx.go
+++ b/x/bank/client/cli/tx.go
@@ -46,7 +46,10 @@ When using '--dry-run' a key name cannot be used, only a bech32 address.
 `,
 		Args: cobra.ExactArgs(3),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cmd.Flags().Set(flags.FlagFrom, args[0])
+			err := cmd.Flags().Set(flags.FlagFrom, args[0])
+			if err != nil {
+				return err
+			}
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
@@ -90,7 +93,10 @@ When using '--dry-run' a key name cannot be used, only a bech32 address.
 `,
 		Args: cobra.MinimumNArgs(4),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cmd.Flags().Set(flags.FlagFrom, args[0])
+			err := cmd.Flags().Set(flags.FlagFrom, args[0])
+			if err != nil {
+				return err
+			}
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
diff --git a/x/bank/keeper/keeper_test.go b/x/bank/keeper/keeper_test.go
index 5ed09a85f6e..859cabd53ac 100644
--- a/x/bank/keeper/keeper_test.go
+++ b/x/bank/keeper/keeper_test.go
@@ -338,18 +338,18 @@ func (suite *KeeperTestSuite) TestSupply_DelegateUndelegateCoins() {
 
 	authKeeper.EXPECT().GetModuleAddress("").Return(nil)
 	require.Panics(func() {
-		_ = keeper.SendCoinsFromModuleToAccount(ctx, "", holderAcc.GetAddress(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
+		_ = keeper.SendCoinsFromModuleToAccount(ctx, "", holderAcc.GetAddress(), initCoins)
 	})
 
 	authKeeper.EXPECT().GetModuleAddress(burnerAcc.Name).Return(burnerAcc.GetAddress())
 	authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
 	require.Panics(func() {
-		_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins) //nolint:errcheck // we're testing for a panic, not an error
+		_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins)
 	})
 
 	authKeeper.EXPECT().GetModuleAddress("").Return(nil)
 	require.Panics(func() {
-		_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
+		_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins)
 	})
 
 	authKeeper.EXPECT().GetModuleAddress(holderAcc.Name).Return(holderAcc.GetAddress())
@@ -399,18 +399,18 @@ func (suite *KeeperTestSuite) TestSupply_SendCoins() {
 
 	authKeeper.EXPECT().GetModuleAddress("").Return(nil)
 	require.Panics(func() {
-		_ = keeper.SendCoinsFromModuleToModule(ctx, "", holderAcc.GetName(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
+		_ = keeper.SendCoinsFromModuleToModule(ctx, "", holderAcc.GetName(), initCoins)
 	})
 
 	authKeeper.EXPECT().GetModuleAddress(burnerAcc.Name).Return(burnerAcc.GetAddress())
 	authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
 	require.Panics(func() {
-		_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins) //nolint:errcheck // we're testing for a panic, not an error
+		_ = keeper.SendCoinsFromModuleToModule(ctx, authtypes.Burner, "", initCoins)
 	})
 
 	authKeeper.EXPECT().GetModuleAddress("").Return(nil)
 	require.Panics(func() {
-		_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins) //nolint:errcheck // we're testing for a panic, not an error
+		_ = keeper.SendCoinsFromModuleToAccount(ctx, "", baseAcc.GetAddress(), initCoins)
 	})
 
 	authKeeper.EXPECT().GetModuleAddress(holderAcc.Name).Return(holderAcc.GetAddress())
@@ -451,16 +451,16 @@ func (suite *KeeperTestSuite) TestSupply_MintCoins() {
 	require.NoError(err)
 
 	authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
-	require.Panics(func() { _ = keeper.MintCoins(ctx, "", initCoins) }, "no module account") //nolint:errcheck // we're testing for a panic, not an error
+	require.Panics(func() { _ = keeper.MintCoins(ctx, "", initCoins) }, "no module account")
 
 	suite.mockMintCoins(burnerAcc)
-	require.Panics(func() { _ = keeper.MintCoins(ctx, authtypes.Burner, initCoins) }, "invalid permission") //nolint:errcheck // we're testing for a panic, not an error
+	require.Panics(func() { _ = keeper.MintCoins(ctx, authtypes.Burner, initCoins) }, "invalid permission")
 
 	suite.mockMintCoins(minterAcc)
 	require.Error(keeper.MintCoins(ctx, authtypes.Minter, sdk.Coins{sdk.Coin{Denom: "denom", Amount: math.NewInt(-10)}}), "insufficient coins")
 
 	authKeeper.EXPECT().GetModuleAccount(ctx, randomPerm).Return(nil)
-	require.Panics(func() { _ = keeper.MintCoins(ctx, randomPerm, initCoins) }) //nolint:errcheck // we're testing for a panic, not an error
+	require.Panics(func() { _ = keeper.MintCoins(ctx, randomPerm, initCoins) })
 
 	suite.mockMintCoins(minterAcc)
 	require.NoError(keeper.MintCoins(ctx, authtypes.Minter, initCoins))
@@ -504,13 +504,13 @@ func (suite *KeeperTestSuite) TestSupply_BurnCoins() {
 	require.NoError(err)
 
 	authKeeper.EXPECT().GetModuleAccount(ctx, "").Return(nil)
-	require.Panics(func() { _ = keeper.BurnCoins(ctx, "", initCoins) }, "no module account") //nolint:errcheck // we're testing for a panic, not an error
+	require.Panics(func() { _ = keeper.BurnCoins(ctx, "", initCoins) }, "no module account")
 
 	authKeeper.EXPECT().GetModuleAccount(ctx, minterAcc.Name).Return(nil)
-	require.Panics(func() { _ = keeper.BurnCoins(ctx, authtypes.Minter, initCoins) }, "invalid permission") //nolint:errcheck // we're testing for a panic, not an error
+	require.Panics(func() { _ = keeper.BurnCoins(ctx, authtypes.Minter, initCoins) }, "invalid permission")
 
 	authKeeper.EXPECT().GetModuleAccount(ctx, randomPerm).Return(nil)
-	require.Panics(func() { _ = keeper.BurnCoins(ctx, randomPerm, supplyAfterInflation) }, "random permission") //nolint:errcheck // we're testing for a panic, not an error
+	require.Panics(func() { _ = keeper.BurnCoins(ctx, randomPerm, supplyAfterInflation) }, "random permission")
 
 	suite.mockBurnCoins(burnerAcc)
 	require.Error(keeper.BurnCoins(ctx, authtypes.Burner, supplyAfterInflation), "insufficient coins")
diff --git a/x/bank/keeper/msg_server_test.go b/x/bank/keeper/msg_server_test.go
index c7d5dde17fd..139cb41e581 100644
--- a/x/bank/keeper/msg_server_test.go
+++ b/x/bank/keeper/msg_server_test.go
@@ -142,11 +142,12 @@ func (suite *KeeperTestSuite) TestMsgSend() {
 		tc := tc
 		suite.Run(tc.name, func() {
 			suite.mockMintCoins(minterAcc)
-			suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
+			err := suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
+			suite.Require().NoError(err)
 			if !tc.expErr {
 				suite.mockSendCoins(suite.ctx, minterAcc, baseAcc.GetAddress())
 			}
-			_, err := suite.msgServer.Send(suite.ctx, tc.input)
+			_, err = suite.msgServer.Send(suite.ctx, tc.input)
 			if tc.expErr {
 				suite.Require().Error(err)
 				suite.Require().Contains(err.Error(), tc.expErrMsg)
@@ -239,11 +240,12 @@ func (suite *KeeperTestSuite) TestMsgMultiSend() {
 		tc := tc
 		suite.Run(tc.name, func() {
 			suite.mockMintCoins(minterAcc)
-			suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
+			err := suite.bankKeeper.MintCoins(suite.ctx, minterAcc.Name, origCoins)
+			suite.Require().NoError(err)
 			if !tc.expErr {
 				suite.mockInputOutputCoins([]sdk.AccountI{minterAcc}, accAddrs[:2])
 			}
-			_, err := suite.msgServer.MultiSend(suite.ctx, tc.input)
+			_, err = suite.msgServer.MultiSend(suite.ctx, tc.input)
 			if tc.expErr {
 				suite.Require().Error(err)
 				suite.Require().Contains(err.Error(), tc.expErrMsg)
diff --git a/x/bank/simulation/operations_test.go b/x/bank/simulation/operations_test.go
index e4f5e03a8a0..cae5cefcb22 100644
--- a/x/bank/simulation/operations_test.go
+++ b/x/bank/simulation/operations_test.go
@@ -106,10 +106,11 @@ func (suite *SimTestSuite) TestSimulateMsgSend() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, 3)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgSend(suite.txConfig, suite.accountKeeper, suite.bankKeeper)
@@ -135,10 +136,11 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, 3)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgMultiSend(suite.txConfig, suite.accountKeeper, suite.bankKeeper)
@@ -170,11 +172,12 @@ func (suite *SimTestSuite) TestSimulateModuleAccountMsgSend() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, accCount)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	},
 	)
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgSendToModuleAccount(suite.txConfig, suite.accountKeeper, suite.bankKeeper, moduleAccCount)
@@ -204,10 +207,11 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSendToModuleAccount() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, accCount)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgMultiSendToModuleAccount(suite.txConfig, suite.accountKeeper, suite.bankKeeper, mAccCount)
diff --git a/x/circuit/ante/circuit_test.go b/x/circuit/ante/circuit_test.go
index 594892652b6..2f40b3475b8 100644
--- a/x/circuit/ante/circuit_test.go
+++ b/x/circuit/ante/circuit_test.go
@@ -78,11 +78,13 @@ func TestCircuitBreakerDecorator(t *testing.T) {
 		// CircuitBreakerDecorator AnteHandler should always return success
 		decorator := ante.NewCircuitBreakerDecorator(circuitBreaker)
 
-		f.txBuilder.SetMsgs(tc.msg)
+		err := f.txBuilder.SetMsgs(tc.msg)
+		require.NoError(t, err)
+
 		tx := f.txBuilder.GetTx()
 
 		sdkCtx := sdk.UnwrapSDKContext(f.ctx)
-		_, err := decorator.AnteHandle(sdkCtx, tx, false, func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) {
+		_, err = decorator.AnteHandle(sdkCtx, tx, false, func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) {
 			return ctx, nil
 		})
 
diff --git a/x/circuit/keeper/keeper_test.go b/x/circuit/keeper/keeper_test.go
index 628d681e451..e0b9fc05300 100644
--- a/x/circuit/keeper/keeper_test.go
+++ b/x/circuit/keeper/keeper_test.go
@@ -102,7 +102,8 @@ func TestIteratePermissions(t *testing.T) {
 		[]byte("mock_address_3"),
 	}
 	for i, addr := range mockAddrs {
-		f.keeper.Permissions.Set(f.ctx, addr, mockPerms[i])
+		err := f.keeper.Permissions.Set(f.ctx, addr, mockPerms[i])
+		require.NoError(t, err)
 	}
 
 	// Define a variable to store the returned permissions
diff --git a/x/consensus/keeper/keeper_test.go b/x/consensus/keeper/keeper_test.go
index 6c36b1c45ee..9ed6f4133fb 100644
--- a/x/consensus/keeper/keeper_test.go
+++ b/x/consensus/keeper/keeper_test.go
@@ -69,7 +69,8 @@ func (s *KeeperTestSuite) TestGRPCQueryConsensusParams() {
 					Validator: defaultConsensusParams.Validator,
 					Evidence:  defaultConsensusParams.Evidence,
 				}
-				s.consensusParamsKeeper.UpdateParams(s.ctx, input)
+				_, err := s.consensusParamsKeeper.UpdateParams(s.ctx, input)
+				s.Require().NoError(err)
 			},
 			types.QueryParamsResponse{
 				Params: &cmtproto.ConsensusParams{
@@ -94,7 +95,8 @@ func (s *KeeperTestSuite) TestGRPCQueryConsensusParams() {
 						VoteExtensionsEnableHeight: 1234,
 					},
 				}
-				s.consensusParamsKeeper.UpdateParams(s.ctx, input)
+				_, err := s.consensusParamsKeeper.UpdateParams(s.ctx, input)
+				s.Require().NoError(err)
 			},
 			types.QueryParamsResponse{
 				Params: &cmtproto.ConsensusParams{
diff --git a/x/distribution/simulation/operations_test.go b/x/distribution/simulation/operations_test.go
index 9da825f3cde..92c89e58069 100644
--- a/x/distribution/simulation/operations_test.go
+++ b/x/distribution/simulation/operations_test.go
@@ -79,7 +79,6 @@ func (suite *SimTestSuite) TestSimulateMsgSetWithdrawAddress() {
 		Hash:   suite.app.LastCommitID().Hash,
 	})
 	suite.Require().NoError(err)
-
 	// execute operation
 	op := simulation.SimulateMsgSetWithdrawAddress(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper)
 	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
@@ -182,7 +181,6 @@ func (suite *SimTestSuite) testSimulateMsgWithdrawValidatorCommission(tokenName
 		Hash:   suite.app.LastCommitID().Hash,
 	})
 	suite.Require().NoError(err)
-
 	// execute operation
 	op := simulation.SimulateMsgWithdrawValidatorCommission(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper, suite.stakingKeeper)
 	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
diff --git a/x/distribution/testutil/staking_helper.go b/x/distribution/testutil/staking_helper.go
index a568898aabf..6f0782362d7 100644
--- a/x/distribution/testutil/staking_helper.go
+++ b/x/distribution/testutil/staking_helper.go
@@ -83,7 +83,10 @@ func SlashValidator(
 			effectiveFraction = math.LegacyOneDec()
 		}
 		// call the before-slashed hook
-		distrKeeper.Hooks().BeforeValidatorSlashed(ctx, validator.GetOperator(), effectiveFraction)
+		err := distrKeeper.Hooks().BeforeValidatorSlashed(ctx, validator.GetOperator(), effectiveFraction)
+		if err != nil {
+			panic(err)
+		}
 	}
 	// Deduct from validator's bonded tokens and update the validator.
 	// Burn the slashed tokens from the pool account and decrease the total supply.
diff --git a/x/feegrant/client/cli/tx.go b/x/feegrant/client/cli/tx.go
index 2b4a8ed45bf..a1040facbd1 100644
--- a/x/feegrant/client/cli/tx.go
+++ b/x/feegrant/client/cli/tx.go
@@ -201,7 +201,9 @@ Example:
 		),
 		Args: cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cmd.Flags().Set(flags.FlagFrom, args[0])
+			if err := cmd.Flags().Set(flags.FlagFrom, args[0]); err != nil {
+				return err
+			}
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
diff --git a/x/feegrant/keeper/keeper.go b/x/feegrant/keeper/keeper.go
index aa491665366..13718020cde 100644
--- a/x/feegrant/keeper/keeper.go
+++ b/x/feegrant/keeper/keeper.go
@@ -244,23 +244,19 @@ func (k Keeper) UseGrantedFees(ctx context.Context, granter, grantee sdk.AccAddr
 	}
 
 	remove, err := grant.Accept(ctx, fee, msgs)
-
 	if remove {
 		// Ignoring the `revokeFeeAllowance` error, because the user has enough grants to perform this transaction.
-		k.revokeAllowance(ctx, granter, grantee)
+		_ = k.revokeAllowance(ctx, granter, grantee)
 		if err != nil {
 			return err
 		}
-
 		emitUseGrantEvent(ctx, granter.String(), grantee.String())
 
 		return nil
 	}
-
 	if err != nil {
 		return err
 	}
-
 	emitUseGrantEvent(ctx, granter.String(), grantee.String())
 
 	// if fee allowance is accepted, store the updated state of the allowance
diff --git a/x/feegrant/keeper/keeper_test.go b/x/feegrant/keeper/keeper_test.go
index de527485fef..91a4a2c508a 100644
--- a/x/feegrant/keeper/keeper_test.go
+++ b/x/feegrant/keeper/keeper_test.go
@@ -308,14 +308,16 @@ func (suite *KeeperTestSuite) TestIterateGrants() {
 		Expiration: &exp,
 	}
 
-	suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[0], suite.addrs[1], allowance)
-	suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[2], suite.addrs[1], allowance1)
-
-	suite.feegrantKeeper.IterateAllFeeAllowances(suite.ctx, func(grant feegrant.Grant) bool {
+	err := suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[0], suite.addrs[1], allowance)
+	suite.Require().NoError(err)
+	err = suite.feegrantKeeper.GrantAllowance(suite.ctx, suite.addrs[2], suite.addrs[1], allowance1)
+	suite.Require().NoError(err)
+	err = suite.feegrantKeeper.IterateAllFeeAllowances(suite.ctx, func(grant feegrant.Grant) bool {
 		suite.Require().Equal(suite.addrs[1].String(), grant.Grantee)
 		suite.Require().Contains([]string{suite.addrs[0].String(), suite.addrs[2].String()}, grant.Granter)
 		return true
 	})
+	suite.Require().NoError(err)
 }
 
 func (suite *KeeperTestSuite) TestPruneGrants() {
@@ -395,7 +397,8 @@ func (suite *KeeperTestSuite) TestPruneGrants() {
 			}
 			err := suite.feegrantKeeper.GrantAllowance(suite.ctx, tc.granter, tc.grantee, tc.allowance)
 			suite.NoError(err)
-			suite.feegrantKeeper.RemoveExpiredAllowances(tc.ctx)
+			err = suite.feegrantKeeper.RemoveExpiredAllowances(tc.ctx)
+			suite.NoError(err)
 			grant, err := suite.feegrantKeeper.GetAllowance(tc.ctx, tc.granter, tc.grantee)
 			if tc.expErrMsg != "" {
 				suite.Error(err)
diff --git a/x/feegrant/keeper/msg_server_test.go b/x/feegrant/keeper/msg_server_test.go
index ea1a6e523aa..5f0ed6862ee 100644
--- a/x/feegrant/keeper/msg_server_test.go
+++ b/x/feegrant/keeper/msg_server_test.go
@@ -237,11 +237,11 @@ func (suite *KeeperTestSuite) TestRevokeAllowance() {
 			},
 			func() {
 				// removing fee allowance from previous tests if exists
-				suite.msgSrvr.RevokeAllowance(suite.ctx, &feegrant.MsgRevokeAllowance{
+				_, err := suite.msgSrvr.RevokeAllowance(suite.ctx, &feegrant.MsgRevokeAllowance{
 					Granter: suite.addrs[0].String(),
 					Grantee: suite.addrs[1].String(),
 				})
-
+				suite.Require().Error(err)
 				any, err := codectypes.NewAnyWithValue(&feegrant.PeriodicAllowance{
 					Basic: feegrant.BasicAllowance{
 						SpendLimit: suite.atom,
diff --git a/x/feegrant/migrations/v2/store.go b/x/feegrant/migrations/v2/store.go
index 48a8d3e3398..72fb847bbb8 100644
--- a/x/feegrant/migrations/v2/store.go
+++ b/x/feegrant/migrations/v2/store.go
@@ -41,7 +41,10 @@ func addAllowancesByExpTimeQueue(ctx context.Context, store store.KVStore, cdc c
 				prefixStore.Delete(key)
 			} else {
 				grantByExpTimeQueueKey := FeeAllowancePrefixQueue(exp, key)
-				store.Set(grantByExpTimeQueueKey, []byte{})
+				err = store.Set(grantByExpTimeQueueKey, []byte{})
+				if err != nil {
+					return err
+				}
 			}
 		}
 	}
diff --git a/x/feegrant/module/abci_test.go b/x/feegrant/module/abci_test.go
index 6e9b1f81ac1..f34bb700bf7 100644
--- a/x/feegrant/module/abci_test.go
+++ b/x/feegrant/module/abci_test.go
@@ -48,7 +48,7 @@ func TestFeegrantPruning(t *testing.T) {
 
 	feegrantKeeper := keeper.NewKeeper(encCfg.Codec, runtime.NewKVStoreService(key), accountKeeper)
 
-	feegrantKeeper.GrantAllowance(
+	err := feegrantKeeper.GrantAllowance(
 		testCtx.Ctx,
 		granter1,
 		grantee,
@@ -56,7 +56,9 @@ func TestFeegrantPruning(t *testing.T) {
 			Expiration: &now,
 		},
 	)
-	feegrantKeeper.GrantAllowance(
+	require.NoError(t, err)
+
+	err = feegrantKeeper.GrantAllowance(
 		testCtx.Ctx,
 		granter2,
 		grantee,
@@ -64,7 +66,9 @@ func TestFeegrantPruning(t *testing.T) {
 			SpendLimit: spendLimit,
 		},
 	)
-	feegrantKeeper.GrantAllowance(
+	require.NoError(t, err)
+
+	err = feegrantKeeper.GrantAllowance(
 		testCtx.Ctx,
 		granter3,
 		grantee,
@@ -72,6 +76,7 @@ func TestFeegrantPruning(t *testing.T) {
 			Expiration: &oneDay,
 		},
 	)
+	require.NoError(t, err)
 
 	queryHelper := baseapp.NewQueryServerTestHelper(testCtx.Ctx, encCfg.InterfaceRegistry)
 	feegrant.RegisterQueryServer(queryHelper, feegrantKeeper)
diff --git a/x/feegrant/simulation/operations.go b/x/feegrant/simulation/operations.go
index 488ab82e8c9..ddbe72ec5bc 100644
--- a/x/feegrant/simulation/operations.go
+++ b/x/feegrant/simulation/operations.go
@@ -138,9 +138,10 @@ func SimulateMsgRevokeAllowance(
 		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string,
 	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
 		hasGrant := false
+
 		var granterAddr sdk.AccAddress
 		var granteeAddr sdk.AccAddress
-		k.IterateAllFeeAllowances(ctx, func(grant feegrant.Grant) bool {
+		err := k.IterateAllFeeAllowances(ctx, func(grant feegrant.Grant) bool {
 			granter, err := ac.StringToBytes(grant.Granter)
 			if err != nil {
 				panic(err)
@@ -154,6 +155,9 @@ func SimulateMsgRevokeAllowance(
 			hasGrant = true
 			return true
 		})
+		if err != nil {
+			return simtypes.OperationMsg{}, nil, err
+		}
 
 		if !hasGrant {
 			return simtypes.NoOpMsg(feegrant.ModuleName, TypeMsgRevokeAllowance, "no grants"), nil, nil
diff --git a/x/feegrant/simulation/operations_test.go b/x/feegrant/simulation/operations_test.go
index 4198d39d55f..a86d13c341e 100644
--- a/x/feegrant/simulation/operations_test.go
+++ b/x/feegrant/simulation/operations_test.go
@@ -178,15 +178,15 @@ func (suite *SimTestSuite) TestSimulateMsgRevokeAllowance() {
 	accounts := suite.getTestingAccounts(r, 3)
 
 	// begin a new block
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
-
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash})
+	require.NoError(err)
 	feeAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
 	feeCoins := sdk.NewCoins(sdk.NewCoin("foo", feeAmt))
 
 	granter, grantee := accounts[0], accounts[1]
 
 	oneYear := ctx.BlockTime().AddDate(1, 0, 0)
-	err := suite.feegrantKeeper.GrantAllowance(
+	err = suite.feegrantKeeper.GrantAllowance(
 		ctx,
 		granter.Address,
 		grantee.Address,
diff --git a/x/genutil/client/cli/init_test.go b/x/genutil/client/cli/init_test.go
index 7ce1d29a432..15df1571b89 100644
--- a/x/genutil/client/cli/init_test.go
+++ b/x/genutil/client/cli/init_test.go
@@ -186,7 +186,9 @@ func TestEmptyState(t *testing.T) {
 	outC := make(chan string)
 	go func() {
 		var buf bytes.Buffer
-		io.Copy(&buf, r)
+		_, err := io.Copy(&buf, r)
+		require.NoError(t, err)
+
 		outC <- buf.String()
 	}()
 
@@ -278,7 +280,8 @@ func TestInitConfig(t *testing.T) {
 	outC := make(chan string)
 	go func() {
 		var buf bytes.Buffer
-		io.Copy(&buf, r)
+		_, err := io.Copy(&buf, r)
+		require.NoError(t, err)
 		outC <- buf.String()
 	}()
 
diff --git a/x/genutil/gentx_test.go b/x/genutil/gentx_test.go
index 505989d97aa..3d7aa4d78f9 100644
--- a/x/genutil/gentx_test.go
+++ b/x/genutil/gentx_test.go
@@ -296,10 +296,11 @@ func (suite *GenTxTestSuite) TestDeliverGenTxs() {
 			if tc.expPass {
 				suite.stakingKeeper.EXPECT().ApplyAndReturnValidatorSetUpdates(gomock.Any()).Return(nil, nil).AnyTimes()
 				suite.Require().NotPanics(func() {
-					genutil.DeliverGenTxs(
+					_, err := genutil.DeliverGenTxs(
 						suite.ctx, genTxs, suite.stakingKeeper, tc.deliverTxFn,
 						suite.encodingConfig.TxConfig,
 					)
+					suite.Require().NoError(err)
 				})
 			} else {
 				_, err := genutil.DeliverGenTxs(
diff --git a/x/gov/abci_test.go b/x/gov/abci_test.go
index 8e4e7ef0715..43e537608b9 100644
--- a/x/gov/abci_test.go
+++ b/x/gov/abci_test.go
@@ -28,11 +28,11 @@ func TestTickExpiredDepositPeriod(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false)
 	addrs := simtestutil.AddTestAddrs(suite.BankKeeper, suite.StakingKeeper, ctx, 10, valTokens)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
-
+	require.NoError(t, err)
 	govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
 
 	checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@@ -79,11 +79,11 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false)
 	addrs := simtestutil.AddTestAddrs(suite.BankKeeper, suite.StakingKeeper, ctx, 10, valTokens)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
-
+	require.NoError(t, err)
 	govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
 
 	checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@@ -150,11 +150,11 @@ func TestTickPassedDepositPeriod(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false)
 	addrs := simtestutil.AddTestAddrs(suite.BankKeeper, suite.StakingKeeper, ctx, 10, valTokens)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
-
+	require.NoError(t, err)
 	govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
 
 	newProposalMsg, err := v1.NewMsgSubmitProposal(
@@ -215,11 +215,11 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 
 			SortAddresses(addrs)
 
-			app.FinalizeBlock(&abci.RequestFinalizeBlock{
+			_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 				Height: app.LastBlockHeight() + 1,
 				Hash:   app.LastCommitID().Hash,
 			})
-
+			require.NoError(t, err)
 			govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
 
 			checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
@@ -309,17 +309,18 @@ func TestProposalPassedEndblocker(t *testing.T) {
 			govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
 			stakingMsgSvr := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
 
-			app.FinalizeBlock(&abci.RequestFinalizeBlock{
+			_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 				Height: app.LastBlockHeight() + 1,
 				Hash:   app.LastCommitID().Hash,
 			})
+			require.NoError(t, err)
 
 			valAddr := sdk.ValAddress(addrs[0])
 			proposer := addrs[0]
 
 			createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10})
-			suite.StakingKeeper.EndBlocker(ctx)
-
+			_, err = suite.StakingKeeper.EndBlocker(ctx)
+			require.NoError(t, err)
 			macc := suite.GovKeeper.GetGovernanceAccount(ctx)
 			require.NotNil(t, macc)
 			initialModuleAccCoins := suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress())
@@ -349,8 +350,8 @@ func TestProposalPassedEndblocker(t *testing.T) {
 			newHeader.Time = ctx.BlockHeader().Time.Add(*params.MaxDepositPeriod).Add(*params.VotingPeriod)
 			ctx = ctx.WithBlockHeader(newHeader)
 
-			gov.EndBlocker(ctx, suite.GovKeeper)
-
+			err = gov.EndBlocker(ctx, suite.GovKeeper)
+			require.NoError(t, err)
 			macc = suite.GovKeeper.GetGovernanceAccount(ctx)
 			require.NotNil(t, macc)
 			require.True(t, suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress()).Equal(initialModuleAccCoins))
@@ -368,17 +369,18 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
 
 	stakingMsgSvr := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	valAddr := sdk.ValAddress(addrs[0])
 	proposer := addrs[0]
 
 	createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10})
-	suite.StakingKeeper.EndBlocker(ctx)
-
+	_, err = suite.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
 	msg := banktypes.NewMsgSend(authtypes.NewModuleAddress(types.ModuleName), addrs[0], sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(100000))))
 	proposal, err := suite.GovKeeper.SubmitProposal(ctx, []sdk.Msg{msg}, "", "title", "summary", proposer, false)
 	require.NoError(t, err)
@@ -400,8 +402,8 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
 	ctx = ctx.WithBlockHeader(newHeader)
 
 	// validate that the proposal fails/has been rejected
-	gov.EndBlocker(ctx, suite.GovKeeper)
-
+	err = gov.EndBlocker(ctx, suite.GovKeeper)
+	require.NoError(t, err)
 	// check proposal events
 	events := ctx.EventManager().Events()
 	attr, eventOk := events.GetAttributes(types.AttributeKeyProposalLog)
@@ -452,18 +454,19 @@ func TestExpeditedProposal_PassAndConversionToRegular(t *testing.T) {
 			govMsgSvr := keeper.NewMsgServerImpl(suite.GovKeeper)
 			stakingMsgSvr := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
 
-			app.FinalizeBlock(&abci.RequestFinalizeBlock{
+			_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 				Height: app.LastBlockHeight() + 1,
 				Hash:   app.LastCommitID().Hash,
 			})
+			require.NoError(t, err)
 
 			valAddr := sdk.ValAddress(addrs[0])
 			proposer := addrs[0]
 
 			// Create a validator so that able to vote on proposal.
 			createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10})
-			suite.StakingKeeper.EndBlocker(ctx)
-
+			_, err = suite.StakingKeeper.EndBlocker(ctx)
+			require.NoError(t, err)
 			checkInactiveProposalsQueue(t, ctx, suite.GovKeeper, true)
 			checkActiveProposalsQueue(t, ctx, suite.GovKeeper, true)
 
@@ -512,8 +515,8 @@ func TestExpeditedProposal_PassAndConversionToRegular(t *testing.T) {
 			}
 
 			// Here the expedited proposal is converted to regular after expiry.
-			gov.EndBlocker(ctx, suite.GovKeeper)
-
+			err = gov.EndBlocker(ctx, suite.GovKeeper)
+			require.NoError(t, err)
 			if tc.expeditedPasses {
 				checkActiveProposalsQueue(t, ctx, suite.GovKeeper, true)
 
@@ -567,8 +570,8 @@ func TestExpeditedProposal_PassAndConversionToRegular(t *testing.T) {
 			}
 
 			// Here we validate the converted regular proposal
-			gov.EndBlocker(ctx, suite.GovKeeper)
-
+			err = gov.EndBlocker(ctx, suite.GovKeeper)
+			require.NoError(t, err)
 			macc = suite.GovKeeper.GetGovernanceAccount(ctx)
 			require.NotNil(t, macc)
 			eventualModuleAccCoins := suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress())
diff --git a/x/gov/client/cli/prompt_test.go b/x/gov/client/cli/prompt_test.go
index e5b01d7da37..6a454b40529 100644
--- a/x/gov/client/cli/prompt_test.go
+++ b/x/gov/client/cli/prompt_test.go
@@ -47,7 +47,8 @@ func TestPromptIntegerOverflow(t *testing.T) {
 
 			fin, fw := readline.NewFillableStdin(os.Stdin)
 			readline.Stdin = fin
-			fw.Write([]byte(overflowStr + "\n"))
+			_, err := fw.Write([]byte(overflowStr + "\n"))
+			assert.NoError(t, err)
 
 			v, err := cli.Prompt(st{}, "")
 			assert.Equal(t, st{}, v, "expected a value of zero")
@@ -78,8 +79,8 @@ func TestPromptParseInteger(t *testing.T) {
 
 			fin, fw := readline.NewFillableStdin(os.Stdin)
 			readline.Stdin = fin
-			fw.Write([]byte(tc.in + "\n"))
-
+			_, err := fw.Write([]byte(tc.in + "\n"))
+			assert.NoError(t, err)
 			v, err := cli.Prompt(st{}, "")
 			assert.Nil(t, err, "expected a nil error")
 			assert.Equal(t, tc.want, v.I, "expected %d = %d", tc.want, v.I)
diff --git a/x/gov/client/cli/util_test.go b/x/gov/client/cli/util_test.go
index 683c3198868..fa5ed1e13bd 100644
--- a/x/gov/client/cli/util_test.go
+++ b/x/gov/client/cli/util_test.go
@@ -41,17 +41,21 @@ func TestParseSubmitLegacyProposal(t *testing.T) {
 	fs := NewCmdSubmitLegacyProposal().Flags()
 
 	// nonexistent json
-	fs.Set(FlagProposal, "fileDoesNotExist")
-	_, err := parseSubmitLegacyProposal(fs)
+	err := fs.Set(FlagProposal, "fileDoesNotExist")
+	require.NoError(t, err)
+
+	_, err = parseSubmitLegacyProposal(fs)
 	require.Error(t, err)
 
 	// invalid json
-	fs.Set(FlagProposal, badJSON.Name())
+	err = fs.Set(FlagProposal, badJSON.Name())
+	require.NoError(t, err)
 	_, err = parseSubmitLegacyProposal(fs)
 	require.Error(t, err)
 
 	// ok json
-	fs.Set(FlagProposal, okJSON.Name())
+	err = fs.Set(FlagProposal, okJSON.Name())
+	require.NoError(t, err)
 	proposal1, err := parseSubmitLegacyProposal(fs)
 	require.Nil(t, err, "unexpected error")
 	require.Equal(t, "Test Proposal", proposal1.Title)
@@ -61,14 +65,17 @@ func TestParseSubmitLegacyProposal(t *testing.T) {
 
 	// flags that can't be used with --proposal
 	for _, incompatibleFlag := range ProposalFlags {
-		fs.Set(incompatibleFlag, "some value")
+		err = fs.Set(incompatibleFlag, "some value")
+		require.NoError(t, err)
 		_, err := parseSubmitLegacyProposal(fs)
 		require.Error(t, err)
-		fs.Set(incompatibleFlag, "")
+		err = fs.Set(incompatibleFlag, "")
+		require.NoError(t, err)
 	}
 
 	// no --proposal, only flags
-	fs.Set(FlagProposal, "")
+	err = fs.Set(FlagProposal, "")
+	require.NoError(t, err)
 	flagTestCases := map[string]struct {
 		pTitle       string
 		pDescription string
@@ -102,10 +109,14 @@ func TestParseSubmitLegacyProposal(t *testing.T) {
 	}
 	for name, tc := range flagTestCases {
 		t.Run(name, func(t *testing.T) {
-			fs.Set(FlagTitle, tc.pTitle)
-			fs.Set(FlagDescription, tc.pDescription)
-			fs.Set(FlagProposalType, tc.pType)
-			fs.Set(FlagDeposit, proposal1.Deposit)
+			err = fs.Set(FlagTitle, tc.pTitle)
+			require.NoError(t, err)
+			err = fs.Set(FlagDescription, tc.pDescription)
+			require.NoError(t, err)
+			err = fs.Set(FlagProposalType, tc.pType)
+			require.NoError(t, err)
+			err = fs.Set(FlagDeposit, proposal1.Deposit)
+			require.NoError(t, err)
 			proposal2, err := parseSubmitLegacyProposal(fs)
 
 			if tc.expErr {
diff --git a/x/gov/client/testutil/helpers.go b/x/gov/client/testutil/helpers.go
index c772126c4bc..9d7f882fdb6 100644
--- a/x/gov/client/testutil/helpers.go
+++ b/x/gov/client/testutil/helpers.go
@@ -20,13 +20,11 @@ var commonArgs = []string{
 }
 
 // MsgSubmitLegacyProposal creates a tx for submit legacy proposal
-//
-//nolint:staticcheck // we are intentionally using a deprecated flag here.
 func MsgSubmitLegacyProposal(clientCtx client.Context, from, title, description, proposalType string, extraArgs ...string) (testutil.BufferWriter, error) {
 	args := append([]string{
 		fmt.Sprintf("--%s=%s", govcli.FlagTitle, title),
-		fmt.Sprintf("--%s=%s", govcli.FlagDescription, description),
-		fmt.Sprintf("--%s=%s", govcli.FlagProposalType, proposalType),
+		fmt.Sprintf("--%s=%s", govcli.FlagDescription, description),   //nolint:staticcheck // we are intentionally using a deprecated flag here.
+		fmt.Sprintf("--%s=%s", govcli.FlagProposalType, proposalType), //nolint:staticcheck // we are intentionally using a deprecated flag here.
 		fmt.Sprintf("--%s=%s", flags.FlagFrom, from),
 	}, commonArgs...)
 
diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go
index ddbd7e5d861..420b4aee4c0 100644
--- a/x/gov/keeper/deposit_test.go
+++ b/x/gov/keeper/deposit_test.go
@@ -136,7 +136,9 @@ func TestDeposits(t *testing.T) {
 			deposit, err = govKeeper.Deposits.Get(ctx, collections.Join(proposalID, TestAddrs[1]))
 			require.Nil(t, err)
 			require.Equal(t, fourStake, sdk.NewCoins(deposit.Amount...))
-			govKeeper.RefundAndDeleteDeposits(ctx, proposalID)
+			err = govKeeper.RefundAndDeleteDeposits(ctx, proposalID)
+			require.NoError(t, err)
+
 			deposit, err = govKeeper.Deposits.Get(ctx, collections.Join(proposalID, TestAddrs[1]))
 			require.ErrorIs(t, err, collections.ErrNotFound)
 			require.Equal(t, addr0Initial, bankKeeper.GetAllBalances(ctx, TestAddrs[0]))
@@ -148,7 +150,9 @@ func TestDeposits(t *testing.T) {
 			proposalID = proposal.Id
 			_, err = govKeeper.AddDeposit(ctx, proposalID, TestAddrs[0], fourStake)
 			require.NoError(t, err)
-			govKeeper.DeleteAndBurnDeposits(ctx, proposalID)
+			err = govKeeper.DeleteAndBurnDeposits(ctx, proposalID)
+			require.NoError(t, err)
+
 			deposits, _ = govKeeper.GetDeposits(ctx, proposalID)
 			require.Len(t, deposits, 0)
 			require.Equal(t, addr0Initial.Sub(fourStake...), bankKeeper.GetAllBalances(ctx, TestAddrs[0]))
@@ -255,9 +259,10 @@ func TestValidateInitialDeposit(t *testing.T) {
 			}
 			params.MinInitialDepositRatio = sdkmath.LegacyNewDec(tc.minInitialDepositPercent).Quo(sdkmath.LegacyNewDec(100)).String()
 
-			govKeeper.Params.Set(ctx, params)
+			err := govKeeper.Params.Set(ctx, params)
+			require.NoError(t, err)
 
-			err := govKeeper.ValidateInitialDeposit(ctx, tc.initialDeposit, tc.expedited)
+			err = govKeeper.ValidateInitialDeposit(ctx, tc.initialDeposit, tc.expedited)
 
 			if tc.expectError {
 				require.Error(t, err)
diff --git a/x/gov/keeper/grpc_query_test.go b/x/gov/keeper/grpc_query_test.go
index 9419b2148e3..4ed4d5e8ccc 100644
--- a/x/gov/keeper/grpc_query_test.go
+++ b/x/gov/keeper/grpc_query_test.go
@@ -276,7 +276,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
 			func() {
 				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit := v1.NewDeposit(testProposals[0].Id, addrs[0], depositCoins)
-				suite.govKeeper.SetDeposit(ctx, deposit)
+				err := suite.govKeeper.SetDeposit(ctx, deposit)
+				suite.Require().NoError(err)
 
 				req = &v1.QueryProposalsRequest{
 					Depositor: addrs[0].String(),
@@ -292,7 +293,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
 			"request with filter of deposit address",
 			func() {
 				testProposals[1].Status = v1.StatusVotingPeriod
-				suite.govKeeper.SetProposal(ctx, *testProposals[1])
+				err := suite.govKeeper.SetProposal(ctx, *testProposals[1])
+				suite.Require().NoError(err)
 				suite.Require().NoError(suite.govKeeper.AddVote(ctx, testProposals[1].Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
 
 				req = &v1.QueryProposalsRequest{
@@ -446,7 +448,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryVote() {
 			"valid request",
 			func() {
 				proposal.Status = v1.StatusVotingPeriod
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 				suite.Require().NoError(suite.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
 
 				req = &v1.QueryVoteRequest{
@@ -560,7 +563,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVote() {
 			"valid request",
 			func() {
 				proposal.Status = v1.StatusVotingPeriod
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 				suite.Require().NoError(suite.govKeeper.AddVote(ctx, proposal.Id, addrs[0], v1.NewNonSplitVoteOption(v1.OptionAbstain), ""))
 
 				req = &v1beta1.QueryVoteRequest{
@@ -663,8 +667,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryVotes() {
 			"request after adding 2 votes",
 			func() {
 				proposal.Status = v1.StatusVotingPeriod
-				suite.govKeeper.SetProposal(ctx, proposal)
-
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 				votes = []*v1.Vote{
 					{ProposalId: proposal.Id, Voter: addrs[0].String(), Options: v1.NewNonSplitVoteOption(v1.OptionAbstain)},
 					{ProposalId: proposal.Id, Voter: addrs[1].String(), Options: v1.NewNonSplitVoteOption(v1.OptionYes)},
@@ -767,7 +771,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVotes() {
 			"request after adding 2 votes",
 			func() {
 				proposal.Status = v1.StatusVotingPeriod
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 
 				votes = []v1beta1.Vote{
 					{ProposalId: proposal.Id, Voter: addrs[0].String(), Options: v1beta1.NewNonSplitVoteOption(v1beta1.OptionAbstain)},
@@ -1057,7 +1062,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() {
 			func() {
 				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit := v1.NewDeposit(proposal.Id, addrs[0], depositCoins)
-				suite.govKeeper.SetDeposit(ctx, deposit)
+				err := suite.govKeeper.SetDeposit(ctx, deposit)
+				suite.Require().NoError(err)
 
 				req = &v1.QueryDepositRequest{
 					ProposalId: proposal.Id,
@@ -1159,7 +1165,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryDeposit() {
 				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit := v1beta1.NewDeposit(proposal.Id, addrs[0], depositCoins)
 				v1deposit := v1.NewDeposit(proposal.Id, addrs[0], depositCoins)
-				suite.govKeeper.SetDeposit(ctx, v1deposit)
+				err := suite.govKeeper.SetDeposit(ctx, v1deposit)
+				suite.Require().NoError(err)
 
 				req = &v1beta1.QueryDepositRequest{
 					ProposalId: proposal.Id,
@@ -1246,11 +1253,13 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() {
 			func() {
 				depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit1 := v1.NewDeposit(proposal.Id, addrs[0], depositAmount1)
-				suite.govKeeper.SetDeposit(ctx, deposit1)
+				err := suite.govKeeper.SetDeposit(ctx, deposit1)
+				suite.Require().NoError(err)
 
 				depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 30)))
 				deposit2 := v1.NewDeposit(proposal.Id, addrs[1], depositAmount2)
-				suite.govKeeper.SetDeposit(ctx, deposit2)
+				err = suite.govKeeper.SetDeposit(ctx, deposit2)
+				suite.Require().NoError(err)
 
 				deposits := v1.Deposits{&deposit1, &deposit2}
 
@@ -1342,12 +1351,14 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryDeposits() {
 				depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit1 := v1beta1.NewDeposit(proposal.Id, addrs[0], depositAmount1)
 				v1deposit1 := v1.NewDeposit(proposal.Id, addrs[0], depositAmount1)
-				suite.govKeeper.SetDeposit(ctx, v1deposit1)
+				err := suite.govKeeper.SetDeposit(ctx, v1deposit1)
+				suite.Require().NoError(err)
 
 				depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.stakingKeeper.TokensFromConsensusPower(ctx, 30)))
 				deposit2 := v1beta1.NewDeposit(proposal.Id, addrs[1], depositAmount2)
 				v1deposit2 := v1.NewDeposit(proposal.Id, addrs[1], depositAmount2)
-				suite.govKeeper.SetDeposit(ctx, v1deposit2)
+				err = suite.govKeeper.SetDeposit(ctx, v1deposit2)
+				suite.Require().NoError(err)
 
 				deposits := v1beta1.Deposits{deposit1, deposit2}
 
@@ -1433,7 +1444,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryTallyResult() {
 					VotingEndTime:   &propTime,
 					Metadata:        "proposal metadata",
 				}
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 
 				req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
 
@@ -1458,7 +1470,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryTallyResult() {
 					VotingEndTime:   &propTime,
 					Metadata:        "proposal metadata",
 				}
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 
 				req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
 
@@ -1483,7 +1496,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryTallyResult() {
 					VotingEndTime:   &propTime,
 					Metadata:        "proposal metadata",
 				}
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 
 				req = &v1.QueryTallyResultRequest{ProposalId: proposal.Id}
 
@@ -1569,7 +1583,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryTallyResult() {
 					VotingEndTime:   &propTime,
 					Metadata:        "proposal metadata",
 				}
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 
 				req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
 
@@ -1594,7 +1609,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryTallyResult() {
 					VotingEndTime:   &propTime,
 					Metadata:        "proposal metadata",
 				}
-				suite.govKeeper.SetProposal(ctx, proposal)
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 
 				req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
 
@@ -1619,8 +1635,8 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryTallyResult() {
 					VotingEndTime:   &propTime,
 					Metadata:        "proposal metadata",
 				}
-				suite.govKeeper.SetProposal(ctx, proposal)
-
+				err := suite.govKeeper.SetProposal(ctx, proposal)
+				suite.Require().NoError(err)
 				req = &v1beta1.QueryTallyResultRequest{ProposalId: proposal.Id}
 
 				expTally = &v1beta1.TallyResult{
diff --git a/x/gov/keeper/hooks_test.go b/x/gov/keeper/hooks_test.go
index 2a8473e56ce..59f1d73c43f 100644
--- a/x/gov/keeper/hooks_test.go
+++ b/x/gov/keeper/hooks_test.go
@@ -75,7 +75,8 @@ func TestHooks(t *testing.T) {
 	newHeader := ctx.BlockHeader()
 	newHeader.Time = ctx.BlockHeader().Time.Add(*params.MaxDepositPeriod).Add(time.Duration(1) * time.Second)
 	ctx = ctx.WithBlockHeader(newHeader)
-	gov.EndBlocker(ctx, govKeeper)
+	err = gov.EndBlocker(ctx, govKeeper)
+	require.NoError(t, err)
 
 	require.True(t, govHooksReceiver.AfterProposalFailedMinDepositValid)
 
@@ -94,6 +95,7 @@ func TestHooks(t *testing.T) {
 	newHeader = ctx.BlockHeader()
 	newHeader.Time = ctx.BlockHeader().Time.Add(*params.VotingPeriod).Add(time.Duration(1) * time.Second)
 	ctx = ctx.WithBlockHeader(newHeader)
-	gov.EndBlocker(ctx, govKeeper)
+	err = gov.EndBlocker(ctx, govKeeper)
+	require.NoError(t, err)
 	require.True(t, govHooksReceiver.AfterProposalVotingPeriodEndedValid)
 }
diff --git a/x/gov/keeper/msg_server_test.go b/x/gov/keeper/msg_server_test.go
index 0720d7b480c..3d8620a6bf4 100644
--- a/x/gov/keeper/msg_server_test.go
+++ b/x/gov/keeper/msg_server_test.go
@@ -1699,7 +1699,8 @@ func (suite *KeeperTestSuite) TestSubmitProposal_InitialDeposit() {
 			params := v1.DefaultParams()
 			params.MinDeposit = tc.minDeposit
 			params.MinInitialDepositRatio = tc.minInitialDepositRatio.String()
-			govKeeper.Params.Set(ctx, params)
+			err := govKeeper.Params.Set(ctx, params)
+			suite.Require().NoError(err)
 
 			msg, err := v1.NewMsgSubmitProposal(TestProposal, tc.initialDeposit, address.String(), "test", "Proposal", "description of proposal", false)
 			suite.Require().NoError(err)
diff --git a/x/gov/keeper/proposal_test.go b/x/gov/keeper/proposal_test.go
index 76152a923dd..7147c7defc8 100644
--- a/x/gov/keeper/proposal_test.go
+++ b/x/gov/keeper/proposal_test.go
@@ -32,7 +32,8 @@ func (suite *KeeperTestSuite) TestGetSetProposal() {
 		proposal, err := suite.govKeeper.SubmitProposal(suite.ctx, tp, "", "test", "summary", suite.addrs[0], tc.expedited)
 		suite.Require().NoError(err)
 		proposalID := proposal.Id
-		suite.govKeeper.SetProposal(suite.ctx, proposal)
+		err = suite.govKeeper.SetProposal(suite.ctx, proposal)
+		suite.Require().NoError(err)
 
 		gotProposal, err := suite.govKeeper.Proposals.Get(suite.ctx, proposalID)
 		suite.Require().Nil(err)
@@ -59,9 +60,12 @@ func (suite *KeeperTestSuite) TestDeleteProposal() {
 		proposal, err := suite.govKeeper.SubmitProposal(suite.ctx, tp, "", "test", "summary", suite.addrs[0], tc.expedited)
 		suite.Require().NoError(err)
 		proposalID := proposal.Id
-		suite.govKeeper.SetProposal(suite.ctx, proposal)
+		err = suite.govKeeper.SetProposal(suite.ctx, proposal)
+		suite.Require().NoError(err)
+
 		suite.Require().NotPanics(func() {
-			suite.govKeeper.DeleteProposal(suite.ctx, proposalID)
+			err := suite.govKeeper.DeleteProposal(suite.ctx, proposalID)
+			suite.Require().NoError(err)
 		}, "")
 	}
 }
@@ -82,7 +86,8 @@ func (suite *KeeperTestSuite) TestActivateVotingPeriod() {
 
 		suite.Require().Nil(proposal.VotingStartTime)
 
-		suite.govKeeper.ActivateVotingPeriod(suite.ctx, proposal)
+		err = suite.govKeeper.ActivateVotingPeriod(suite.ctx, proposal)
+		suite.Require().NoError(err)
 
 		proposal, err = suite.govKeeper.Proposals.Get(suite.ctx, proposal.Id)
 		suite.Require().Nil(err)
@@ -238,8 +243,8 @@ func (suite *KeeperTestSuite) TestCancelProposal() {
 				suite.Require().Nil(err)
 
 				proposal2.Status = v1.ProposalStatus_PROPOSAL_STATUS_PASSED
-				suite.govKeeper.SetProposal(suite.ctx, proposal2)
-
+				err = suite.govKeeper.SetProposal(suite.ctx, proposal2)
+				suite.Require().NoError(err)
 				return proposal2ID, suite.addrs[1].String()
 			},
 			expectedErr: true,
diff --git a/x/gov/keeper/vote_test.go b/x/gov/keeper/vote_test.go
index aa93118ad4a..fc969f01a77 100644
--- a/x/gov/keeper/vote_test.go
+++ b/x/gov/keeper/vote_test.go
@@ -31,7 +31,8 @@ func TestVotes(t *testing.T) {
 	require.Error(t, govKeeper.AddVote(ctx, 10, addrs[0], v1.NewNonSplitVoteOption(v1.OptionYes), ""), "invalid proposal ID")
 
 	proposal.Status = v1.StatusVotingPeriod
-	govKeeper.SetProposal(ctx, proposal)
+	err = govKeeper.SetProposal(ctx, proposal)
+	require.NoError(t, err)
 
 	require.Error(t, govKeeper.AddVote(ctx, proposalID, addrs[0], v1.NewNonSplitVoteOption(invalidOption), ""), "invalid option")
 
diff --git a/x/gov/migrations/v5/store.go b/x/gov/migrations/v5/store.go
index ddfa20f5292..018dfacb5a4 100644
--- a/x/gov/migrations/v5/store.go
+++ b/x/gov/migrations/v5/store.go
@@ -38,7 +38,5 @@ func MigrateStore(ctx sdk.Context, storeService corestoretypes.KVStoreService, c
 		return err
 	}
 
-	store.Set(v4.ParamsKey, bz)
-
-	return nil
+	return store.Set(v4.ParamsKey, bz)
 }
diff --git a/x/gov/simulation/operations_test.go b/x/gov/simulation/operations_test.go
index e0201f2b1d4..c4c3355cd9d 100644
--- a/x/gov/simulation/operations_test.go
+++ b/x/gov/simulation/operations_test.go
@@ -143,10 +143,11 @@ func TestSimulateMsgSubmitProposal(t *testing.T) {
 	r := rand.New(s)
 	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	// execute operation
 	op := simulation.SimulateMsgSubmitProposal(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, MockWeightedProposals{3}.MsgSimulatorFn())
@@ -174,10 +175,11 @@ func TestSimulateMsgSubmitLegacyProposal(t *testing.T) {
 	r := rand.New(s)
 	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	// execute operation
 	op := simulation.SimulateMsgSubmitLegacyProposal(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, MockWeightedProposals{3}.ContentSimulatorFn())
@@ -230,12 +232,14 @@ func TestSimulateMsgCancelProposal(t *testing.T) {
 	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "title", "summary", proposer, false)
 	require.NoError(t, err)
 
-	suite.GovKeeper.SetProposal(ctx, proposal)
+	err = suite.GovKeeper.SetProposal(ctx, proposal)
+	require.NoError(t, err)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	// execute operation
 	op := simulation.SimulateMsgCancelProposal(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper)
@@ -277,12 +281,14 @@ func TestSimulateMsgDeposit(t *testing.T) {
 	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "text proposal", "description", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r"), false)
 	require.NoError(t, err)
 
-	suite.GovKeeper.SetProposal(ctx, proposal)
+	err = suite.GovKeeper.SetProposal(ctx, proposal)
+	require.NoError(t, err)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	// execute operation
 	op := simulation.SimulateMsgDeposit(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper)
@@ -325,12 +331,14 @@ func TestSimulateMsgVote(t *testing.T) {
 	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "text proposal", "description", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r"), false)
 	require.NoError(t, err)
 
-	suite.GovKeeper.ActivateVotingPeriod(ctx, proposal)
+	err = suite.GovKeeper.ActivateVotingPeriod(ctx, proposal)
+	require.NoError(t, err)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	// execute operation
 	op := simulation.SimulateMsgVote(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper)
@@ -371,12 +379,14 @@ func TestSimulateMsgVoteWeighted(t *testing.T) {
 	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "text proposal", "test", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r"), false)
 	require.NoError(t, err)
 
-	suite.GovKeeper.ActivateVotingPeriod(ctx, proposal)
+	err = suite.GovKeeper.ActivateVotingPeriod(ctx, proposal)
+	require.NoError(t, err)
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: app.LastBlockHeight() + 1,
 		Hash:   app.LastCommitID().Hash,
 	})
+	require.NoError(t, err)
 
 	// execute operation
 	op := simulation.SimulateMsgVoteWeighted(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper)
diff --git a/x/group/client/cli/tx.go b/x/group/client/cli/tx.go
index ae2bae839dc..fe1dbc4263a 100644
--- a/x/group/client/cli/tx.go
+++ b/x/group/client/cli/tx.go
@@ -621,7 +621,10 @@ metadata example:
 			if prop.Proposers == nil || len(prop.Proposers) == 0 {
 				return errors.New("no proposers specified in proposal")
 			}
-			cmd.Flags().Set(flags.FlagFrom, prop.Proposers[0])
+			err = cmd.Flags().Set(flags.FlagFrom, prop.Proposers[0])
+			if err != nil {
+				return err
+			}
 
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
@@ -808,7 +811,10 @@ Parameters:
 		`,
 		Args: cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cmd.Flags().Set(flags.FlagFrom, args[0])
+			err := cmd.Flags().Set(flags.FlagFrom, args[0])
+			if err != nil {
+				return err
+			}
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
diff --git a/x/group/internal/orm/iterator_property_test.go b/x/group/internal/orm/iterator_property_test.go
index 8a1b473fea5..25ba5343d07 100644
--- a/x/group/internal/orm/iterator_property_test.go
+++ b/x/group/internal/orm/iterator_property_test.go
@@ -42,7 +42,8 @@ func TestPaginationProperty(t *testing.T) {
 			}
 			dest := reconstructedTableModels[offset:end]
 			tableModelsIt := testTableModelIterator(tableModels, nil)
-			Paginate(tableModelsIt, pageRequest, &dest)
+			_, err := Paginate(tableModelsIt, pageRequest, &dest)
+			require.NoError(t, err)
 			reconstructedTableModels = append(reconstructedTableModels, dest...)
 		}
 
diff --git a/x/group/internal/orm/orm_scenario_test.go b/x/group/internal/orm/orm_scenario_test.go
index e613b8937a7..aaab3ed2d0c 100644
--- a/x/group/internal/orm/orm_scenario_test.go
+++ b/x/group/internal/orm/orm_scenario_test.go
@@ -335,7 +335,8 @@ func TestExportImportStateAutoUInt64Table(t *testing.T) {
 		it, err := k.autoUInt64TableModelByMetadataIndex.Get(store, exp)
 		require.NoError(t, err)
 		var all []testdata.TableModel
-		ReadAll(it, &all)
+		_, err = ReadAll(it, &all)
+		require.NoError(t, err)
 		require.Len(t, all, 1)
 		assert.Equal(t, loaded, all[0])
 	}
diff --git a/x/group/internal/orm/table.go b/x/group/internal/orm/table.go
index b2024fad011..c99d41d1c1f 100644
--- a/x/group/internal/orm/table.go
+++ b/x/group/internal/orm/table.go
@@ -117,7 +117,11 @@ func (a table) Set(store types.KVStore, rowID RowID, newValue proto.Message) err
 	var oldValue proto.Message
 	if a.Has(store, rowID) {
 		oldValue = reflect.New(a.model).Interface().(proto.Message)
-		a.GetOne(store, rowID, oldValue)
+		err := a.GetOne(store, rowID, oldValue)
+		if err != nil {
+			return err
+		}
+
 	}
 
 	newValueEncoded, err := a.cdc.Marshal(newValue)
diff --git a/x/group/keeper/keeper_test.go b/x/group/keeper/keeper_test.go
index 5b06edba5b5..4acc177b055 100644
--- a/x/group/keeper/keeper_test.go
+++ b/x/group/keeper/keeper_test.go
@@ -117,9 +117,11 @@ func (s *TestSuite) SetupTest() {
 	s.groupPolicyAddr = addrbz
 
 	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)})
+	err = s.bankKeeper.MintCoins(s.sdkCtx, minttypes.ModuleName, sdk.Coins{sdk.NewInt64Coin("test", 100000)})
+	s.Require().NoError(err)
 	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)})
+	err = s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)})
+	s.Require().NoError(err)
 }
 
 func (s *TestSuite) setNextAccount() {
@@ -135,8 +137,7 @@ func (s *TestSuite) setNextAccount() {
 
 	groupPolicyAccBumpAccountNumber, err := authtypes.NewBaseAccountWithPubKey(ac)
 	s.Require().NoError(err)
-	groupPolicyAccBumpAccountNumber.SetAccountNumber(nextAccVal)
-
+	err = groupPolicyAccBumpAccountNumber.SetAccountNumber(nextAccVal)
 	s.Require().NoError(err)
 
 	s.accountKeeper.EXPECT().GetAccount(gomock.Any(), sdk.AccAddress(ac.Address())).Return(nil).AnyTimes()
@@ -268,10 +269,12 @@ func (s *TestSuite) TestProposalsByVPEnd() {
 		s.Run(msg, func() {
 			pID := spec.preRun(s.sdkCtx)
 
-			module.EndBlocker(spec.newCtx, s.groupKeeper)
+			err := module.EndBlocker(spec.newCtx, s.groupKeeper)
+			s.Require().NoError(err)
 			resp, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
 				ProposalId: pID,
 			})
+			s.Require().NoError(err)
 
 			if spec.expErrMsg != "" {
 				s.Require().Error(err)
@@ -452,7 +455,12 @@ func (s *TestSuite) TestTallyProposalsAtVPEnd() {
 	s.Require().NoError(err)
 
 	s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx))
-	s.NotPanics(func() { module.EndBlocker(ctx, s.groupKeeper) })
+	s.NotPanics(func() {
+		err := module.EndBlocker(ctx, s.groupKeeper)
+		if err != nil {
+			panic(err)
+		}
+	})
 }
 
 // TestTallyProposalsAtVPEnd_GroupMemberLeaving test that the node doesn't
@@ -514,7 +522,12 @@ func (s *TestSuite) TestTallyProposalsAtVPEnd_GroupMemberLeaving() {
 
 	// Tally the result. This saves the tally result to state.
 	s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx))
-	s.NotPanics(func() { module.EndBlocker(ctx, s.groupKeeper) })
+	s.NotPanics(func() {
+		err := module.EndBlocker(ctx, s.groupKeeper)
+		if err != nil {
+			panic(err)
+		}
+	})
 
 	// member 2 (high weight) leaves group.
 	_, err = s.groupKeeper.LeaveGroup(ctx, &group.MsgLeaveGroup{
@@ -524,5 +537,10 @@ func (s *TestSuite) TestTallyProposalsAtVPEnd_GroupMemberLeaving() {
 	s.Require().NoError(err)
 
 	s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx))
-	s.NotPanics(func() { module.EndBlocker(ctx, s.groupKeeper) })
+	s.NotPanics(func() {
+		err := module.EndBlocker(ctx, s.groupKeeper)
+		if err != nil {
+			panic(err)
+		}
+	})
 }
diff --git a/x/group/keeper/msg_server_test.go b/x/group/keeper/msg_server_test.go
index c0f24626617..6d6d24c3b09 100644
--- a/x/group/keeper/msg_server_test.go
+++ b/x/group/keeper/msg_server_test.go
@@ -3332,9 +3332,11 @@ func (s *TestSuite) TestExecProposalsWhenMemberLeavesOrIsUpdated() {
 					Admin:              s.addrs[0].String(),
 					GroupPolicyAddress: groupPolicyAddr,
 				}
-				newGroupPolicy.SetDecisionPolicy(group.NewThresholdDecisionPolicy("10", time.Second, minExecutionPeriod))
-
-				_, err := k.UpdateGroupPolicyDecisionPolicy(ctx, newGroupPolicy)
+				err := newGroupPolicy.SetDecisionPolicy(group.NewThresholdDecisionPolicy("10", time.Second, minExecutionPeriod))
+				if err != nil {
+					return err
+				}
+				_, err = k.UpdateGroupPolicyDecisionPolicy(ctx, newGroupPolicy)
 				return err
 			},
 			expErrMsg: "PROPOSAL_STATUS_ABORTED",
diff --git a/x/group/module/abci_test.go b/x/group/module/abci_test.go
index 9bdab6ebd5a..79a7829a485 100644
--- a/x/group/module/abci_test.go
+++ b/x/group/module/abci_test.go
@@ -339,7 +339,8 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
 		s.Run(msg, func() {
 			proposalID := spec.setupProposal(ctx)
 
-			module.EndBlocker(spec.newCtx, s.groupKeeper)
+			err := module.EndBlocker(spec.newCtx, s.groupKeeper)
+			s.Require().NoError(err)
 
 			if spec.expErrMsg != "" && spec.expExecutorResult != group.PROPOSAL_EXECUTOR_RESULT_SUCCESS {
 				_, err = s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{ProposalId: proposalID})
@@ -541,7 +542,8 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
 			spec := spec
 			pID := spec.preRun(ctx)
 
-			module.EndBlocker(spec.newCtx, s.groupKeeper)
+			err := module.EndBlocker(spec.newCtx, s.groupKeeper)
+			s.Require().NoError(err)
 			resp, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
 				ProposalId: pID,
 			})
diff --git a/x/group/simulation/operations.go b/x/group/simulation/operations.go
index fe7d04833c4..6de966432fb 100644
--- a/x/group/simulation/operations.go
+++ b/x/group/simulation/operations.go
@@ -297,7 +297,7 @@ func SimulateMsgCreateGroupWithPolicy(
 			GroupPolicyMetadata: simtypes.RandStringOfLength(r, 10),
 			GroupPolicyAsAdmin:  r.Float32() < 0.5,
 		}
-		msg.SetDecisionPolicy(decisionPolicy)
+		err = msg.SetDecisionPolicy(decisionPolicy)
 		if err != nil {
 			return simtypes.NoOpMsg(group.ModuleName, sdk.MsgTypeURL(msg), "unable to set decision policy"), nil, err
 		}
diff --git a/x/group/simulation/operations_test.go b/x/group/simulation/operations_test.go
index b00039145b8..7463bccb7bd 100644
--- a/x/group/simulation/operations_test.go
+++ b/x/group/simulation/operations_test.go
@@ -130,10 +130,11 @@ func (suite *SimTestSuite) TestSimulateCreateGroup() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, 1)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	acc := accounts[0]
 
@@ -156,10 +157,11 @@ func (suite *SimTestSuite) TestSimulateCreateGroupWithPolicy() {
 	r := rand.New(s)
 	accounts := suite.getTestingAccounts(r, 1)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	acc := accounts[0]
 
@@ -197,10 +199,11 @@ func (suite *SimTestSuite) TestSimulateCreateGroupPolicy() {
 	)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgCreateGroupPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -247,10 +250,11 @@ func (suite *SimTestSuite) TestSimulateSubmitProposal() {
 	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgSubmitProposal(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -310,10 +314,11 @@ func (suite *SimTestSuite) TestWithdrawProposal() {
 	_, err = suite.groupKeeper.SubmitProposal(ctx, proposalReq)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgWithdrawProposal(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -374,10 +379,11 @@ func (suite *SimTestSuite) TestSimulateVote() {
 	_, err = suite.groupKeeper.SubmitProposal(ctx, proposalReq)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgVote(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -446,10 +452,11 @@ func (suite *SimTestSuite) TestSimulateExec() {
 	})
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgExec(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -485,10 +492,11 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupAdmin() {
 	)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgUpdateGroupAdmin(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -524,10 +532,11 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupMetadata() {
 	)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgUpdateGroupMetadata(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -563,10 +572,11 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupMembers() {
 	)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgUpdateGroupMembers(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -613,10 +623,11 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyAdmin() {
 	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgUpdateGroupPolicyAdmin(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -663,10 +674,11 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyDecisionPolicy() {
 	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgUpdateGroupPolicyDecisionPolicy(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -713,10 +725,11 @@ func (suite *SimTestSuite) TestSimulateUpdateGroupPolicyMetadata() {
 	groupPolicyRes, err := suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
 	suite.Require().NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	suite.Require().NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgUpdateGroupPolicyMetadata(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.groupKeeper)
@@ -776,10 +789,11 @@ func (suite *SimTestSuite) TestSimulateLeaveGroup() {
 	_, err = suite.groupKeeper.CreateGroupPolicy(ctx, accountReq)
 	require.NoError(err)
 
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err = suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
+	require.NoError(err)
 
 	// execute operation
 	op := simulation.SimulateMsgLeaveGroup(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.groupKeeper, suite.accountKeeper, suite.bankKeeper)
diff --git a/x/mint/keeper/grpc_query_test.go b/x/mint/keeper/grpc_query_test.go
index 5f6227ee141..6243e0cbe7d 100644
--- a/x/mint/keeper/grpc_query_test.go
+++ b/x/mint/keeper/grpc_query_test.go
@@ -57,7 +57,6 @@ func (suite *MintTestSuite) SetupTest() {
 	err := suite.mintKeeper.Params.Set(suite.ctx, types.DefaultParams())
 	suite.Require().NoError(err)
 	suite.Require().NoError(suite.mintKeeper.Minter.Set(suite.ctx, types.DefaultInitialMinter()))
-
 	queryHelper := baseapp.NewQueryServerTestHelper(testCtx.Ctx, encCfg.InterfaceRegistry)
 	types.RegisterQueryServer(queryHelper, keeper.NewQueryServerImpl(suite.mintKeeper))
 
diff --git a/x/mint/keeper/keeper_test.go b/x/mint/keeper/keeper_test.go
index 2ee25b6a53a..aac06904e5d 100644
--- a/x/mint/keeper/keeper_test.go
+++ b/x/mint/keeper/keeper_test.go
@@ -66,8 +66,8 @@ func (s *IntegrationTestSuite) SetupTest() {
 
 	err := s.mintKeeper.Params.Set(s.ctx, types.DefaultParams())
 	s.Require().NoError(err)
-	s.Require().NoError(s.mintKeeper.Minter.Set(s.ctx, types.DefaultInitialMinter()))
 
+	s.Require().NoError(s.mintKeeper.Minter.Set(s.ctx, types.DefaultInitialMinter()))
 	s.msgServer = keeper.NewMsgServerImpl(s.mintKeeper)
 }
 
diff --git a/x/nft/keeper/msg_server.go b/x/nft/keeper/msg_server.go
index 2f48298714f..cc24d447323 100644
--- a/x/nft/keeper/msg_server.go
+++ b/x/nft/keeper/msg_server.go
@@ -43,11 +43,14 @@ func (k Keeper) Send(goCtx context.Context, msg *nft.MsgSend) (*nft.MsgSendRespo
 		return nil, err
 	}
 
-	ctx.EventManager().EmitTypedEvent(&nft.EventSend{
+	err = ctx.EventManager().EmitTypedEvent(&nft.EventSend{
 		ClassId:  msg.ClassId,
 		Id:       msg.Id,
 		Sender:   msg.Sender,
 		Receiver: msg.Receiver,
 	})
+	if err != nil {
+		return nil, err
+	}
 	return &nft.MsgSendResponse{}, nil
 }
diff --git a/x/nft/keeper/nft.go b/x/nft/keeper/nft.go
index a2f1426891b..5f0d21bf8ea 100644
--- a/x/nft/keeper/nft.go
+++ b/x/nft/keeper/nft.go
@@ -33,11 +33,14 @@ func (k Keeper) mintWithNoCheck(ctx context.Context, token nft.NFT, receiver sdk
 	k.setOwner(ctx, token.ClassId, token.Id, receiver)
 	k.incrTotalSupply(ctx, token.ClassId)
 
-	sdk.UnwrapSDKContext(ctx).EventManager().EmitTypedEvent(&nft.EventMint{
+	err := sdk.UnwrapSDKContext(ctx).EventManager().EmitTypedEvent(&nft.EventMint{
 		ClassId: token.ClassId,
 		Id:      token.Id,
 		Owner:   receiver.String(),
 	})
+	if err != nil {
+		panic(err)
+	}
 }
 
 // Burn defines a method for burning a nft from a specific account.
@@ -51,7 +54,10 @@ func (k Keeper) Burn(ctx context.Context, classID, nftID string) error {
 		return errors.Wrap(nft.ErrNFTNotExists, nftID)
 	}
 
-	k.burnWithNoCheck(ctx, classID, nftID)
+	err := k.burnWithNoCheck(ctx, classID, nftID)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -65,11 +71,14 @@ func (k Keeper) burnWithNoCheck(ctx context.Context, classID, nftID string) erro
 
 	k.deleteOwner(ctx, classID, nftID, owner)
 	k.decrTotalSupply(ctx, classID)
-	sdk.UnwrapSDKContext(ctx).EventManager().EmitTypedEvent(&nft.EventBurn{
+	err := sdk.UnwrapSDKContext(ctx).EventManager().EmitTypedEvent(&nft.EventBurn{
 		ClassId: classID,
 		Id:      nftID,
 		Owner:   owner.String(),
 	})
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -109,7 +118,10 @@ func (k Keeper) Transfer(ctx context.Context,
 		return errors.Wrap(nft.ErrNFTNotExists, nftID)
 	}
 
-	k.transferWithNoCheck(ctx, classID, nftID, receiver)
+	err := k.transferWithNoCheck(ctx, classID, nftID, receiver)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -206,7 +218,10 @@ func (k Keeper) setNFT(ctx context.Context, token nft.NFT) {
 
 func (k Keeper) setOwner(ctx context.Context, classID, nftID string, owner sdk.AccAddress) {
 	store := k.storeService.OpenKVStore(ctx)
-	store.Set(ownerStoreKey(classID, nftID), owner.Bytes())
+	err := store.Set(ownerStoreKey(classID, nftID), owner.Bytes())
+	if err != nil {
+		panic(err)
+	}
 
 	ownerStore := k.getClassStoreByOwner(ctx, owner, classID)
 	ownerStore.Set([]byte(nftID), Placeholder)
@@ -214,8 +229,10 @@ func (k Keeper) setOwner(ctx context.Context, classID, nftID string, owner sdk.A
 
 func (k Keeper) deleteOwner(ctx context.Context, classID, nftID string, owner sdk.AccAddress) {
 	store := k.storeService.OpenKVStore(ctx)
-	store.Delete(ownerStoreKey(classID, nftID))
-
+	err := store.Delete(ownerStoreKey(classID, nftID))
+	if err != nil {
+		panic(err)
+	}
 	ownerStore := k.getClassStoreByOwner(ctx, owner, classID)
 	ownerStore.Delete([]byte(nftID))
 }
diff --git a/x/nft/keeper/nft_batch_test.go b/x/nft/keeper/nft_batch_test.go
index 16731da9565..2e356f0fb76 100644
--- a/x/nft/keeper/nft_batch_test.go
+++ b/x/nft/keeper/nft_batch_test.go
@@ -86,7 +86,8 @@ func (s *TestSuite) TestBatchMint() {
 			func(tokens []nft.NFT) {
 				s.saveClass(tokens)
 				idx := rand.Intn(len(tokens))
-				s.nftKeeper.Mint(s.ctx, tokens[idx], receiver)
+				err := s.nftKeeper.Mint(s.ctx, tokens[idx], receiver)
+				s.Require().NoError(err)
 			},
 			[]nft.NFT{
 				{ClassId: "classID1", Id: "nftID1"},
@@ -156,7 +157,8 @@ func (s *TestSuite) TestBatchBurn() {
 			"success",
 			func() {
 				s.saveClass(tokens)
-				s.nftKeeper.BatchMint(s.ctx, tokens, receiver)
+				err := s.nftKeeper.BatchMint(s.ctx, tokens, receiver)
+				s.Require().NoError(err)
 			},
 			"classID1",
 			[]string{"nftID1", "nftID2"},
@@ -216,7 +218,8 @@ func (s *TestSuite) TestBatchUpdate() {
 			"success",
 			func() {
 				s.saveClass(tokens)
-				s.nftKeeper.BatchMint(s.ctx, tokens, receiver)
+				err := s.nftKeeper.BatchMint(s.ctx, tokens, receiver)
+				s.Require().NoError(err)
 			},
 			[]nft.NFT{
 				{ClassId: "classID1", Id: "nftID1", Uri: "nftID1_URI"},
@@ -286,7 +289,8 @@ func (s *TestSuite) TestBatchTransfer() {
 			"success",
 			func() {
 				s.saveClass(tokens)
-				s.nftKeeper.BatchMint(s.ctx, tokens, owner)
+				err := s.nftKeeper.BatchMint(s.ctx, tokens, owner)
+				s.Require().NoError(err)
 			},
 			"classID1",
 			[]string{"nftID1", "nftID2"},
@@ -296,7 +300,8 @@ func (s *TestSuite) TestBatchTransfer() {
 			"failed with not exist classID",
 			func() {
 				s.saveClass(tokens)
-				s.nftKeeper.BatchMint(s.ctx, tokens, receiver)
+				err := s.nftKeeper.BatchMint(s.ctx, tokens, receiver)
+				s.Require().NoError(err)
 			},
 			"classID3",
 			[]string{"nftID1", "nftID2"},
diff --git a/x/nft/simulation/operations_test.go b/x/nft/simulation/operations_test.go
index fad8cf9996e..4514493aca2 100644
--- a/x/nft/simulation/operations_test.go
+++ b/x/nft/simulation/operations_test.go
@@ -6,6 +6,7 @@ import (
 	"time"
 
 	abci "github.com/cometbft/cometbft/abci/types"
+	"github.com/cosmos/gogoproto/proto"
 	"github.com/stretchr/testify/suite"
 
 	"cosmossdk.io/depinject"
@@ -124,11 +125,11 @@ func (suite *SimTestSuite) TestSimulateMsgSend() {
 	ctx := suite.ctx.WithBlockTime(blockTime)
 
 	// begin new block
-	suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
+	_, err := suite.app.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.app.LastBlockHeight() + 1,
 		Hash:   suite.app.LastCommitID().Hash,
 	})
-
+	suite.Require().NoError(err)
 	// execute operation
 	registry := suite.interfaceRegistry
 	op := simulation.SimulateMsgSend(codec.NewProtoCodec(registry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.nftKeeper)
@@ -136,7 +137,8 @@ func (suite *SimTestSuite) TestSimulateMsgSend() {
 	suite.Require().NoError(err)
 
 	var msg nft.MsgSend
-	suite.codec.UnmarshalJSON(operationMsg.Msg, &msg)
+	err = proto.Unmarshal(operationMsg.Msg, &msg)
+	suite.Require().NoError(err)
 	suite.Require().True(operationMsg.OK)
 	suite.Require().Len(futureOperations, 0)
 }
diff --git a/x/params/types/subspace_test.go b/x/params/types/subspace_test.go
index a9a1e7ebcc5..b36670fe6c3 100644
--- a/x/params/types/subspace_test.go
+++ b/x/params/types/subspace_test.go
@@ -154,7 +154,8 @@ func (suite *SubspaceTestSuite) TestModified() {
 
 func (suite *SubspaceTestSuite) TestUpdate() {
 	suite.Require().Panics(func() {
-		suite.ss.Update(suite.ctx, []byte("invalid_key"), nil)
+		err := suite.ss.Update(suite.ctx, []byte("invalid_key"), nil)
+		suite.Require().NoError(err)
 	})
 
 	t := time.Hour * 48
diff --git a/x/simulation/simulate.go b/x/simulation/simulate.go
index 3a118dde713..380034ebe6e 100644
--- a/x/simulation/simulate.go
+++ b/x/simulation/simulate.go
@@ -225,7 +225,11 @@ func SimulateFromSeed(
 		logWriter.AddEntry(EndBlockEntry(blockHeight))
 
 		if config.Commit {
-			app.Commit()
+			_, err := app.Commit()
+			if err != nil {
+				return true, params, err
+			}
+
 		}
 
 		if proposerAddress == nil {
diff --git a/x/slashing/abci_test.go b/x/slashing/abci_test.go
index 792f391f85b..d5ebe2a9900 100644
--- a/x/slashing/abci_test.go
+++ b/x/slashing/abci_test.go
@@ -51,7 +51,8 @@ func TestBeginBlocker(t *testing.T) {
 	// bond the validator
 	power := int64(100)
 	amt := tstaking.CreateValidatorWithValPower(addr, pk, power, true)
-	stakingKeeper.EndBlocker(ctx)
+	_, err = stakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
 	bondDenom, err := stakingKeeper.BondDenom(ctx)
 	require.NoError(t, err)
 	require.Equal(
diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go
index 6c42e1dc9d4..01f82303ab1 100644
--- a/x/slashing/app_test.go
+++ b/x/slashing/app_test.go
@@ -91,8 +91,8 @@ func TestSlashingMsgs(t *testing.T) {
 	require.NoError(t, err)
 	require.True(t, sdk.Coins{genCoin.Sub(bondCoin)}.Equal(bankKeeper.GetAllBalances(ctxCheck, addr1)))
 
-	app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: app.LastBlockHeight() + 1})
-
+	_, err = app.FinalizeBlock(&abci.RequestFinalizeBlock{Height: app.LastBlockHeight() + 1})
+	require.NoError(t, err)
 	ctxCheck = baseApp.NewContext(true)
 	validator, err := stakingKeeper.GetValidator(ctxCheck, sdk.ValAddress(addr1))
 	require.NoError(t, err)
diff --git a/x/slashing/keeper/genesis.go b/x/slashing/keeper/genesis.go
index 379bb359c2f..446ff0a89b1 100644
--- a/x/slashing/keeper/genesis.go
+++ b/x/slashing/keeper/genesis.go
@@ -9,24 +9,33 @@ import (
 // InitGenesis initializes default parameters and the keeper's address to
 // pubkey map.
 func (keeper Keeper) InitGenesis(ctx sdk.Context, stakingKeeper types.StakingKeeper, data *types.GenesisState) {
-	stakingKeeper.IterateValidators(ctx,
+	err := stakingKeeper.IterateValidators(ctx,
 		func(index int64, validator stakingtypes.ValidatorI) bool {
 			consPk, err := validator.ConsPubKey()
 			if err != nil {
 				panic(err)
 			}
 
-			keeper.AddPubkey(ctx, consPk)
+			err = keeper.AddPubkey(ctx, consPk)
+			if err != nil {
+				panic(err)
+			}
 			return false
 		},
 	)
+	if err != nil {
+		panic(err)
+	}
 
 	for _, info := range data.SigningInfos {
 		address, err := sdk.ConsAddressFromBech32(info.Address)
 		if err != nil {
 			panic(err)
 		}
-		keeper.SetValidatorSigningInfo(ctx, address, info.ValidatorSigningInfo)
+		err = keeper.SetValidatorSigningInfo(ctx, address, info.ValidatorSigningInfo)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	for _, array := range data.MissedBlocks {
@@ -57,7 +66,7 @@ func (keeper Keeper) ExportGenesis(ctx sdk.Context) (data *types.GenesisState) {
 	}
 	signingInfos := make([]types.SigningInfo, 0)
 	missedBlocks := make([]types.ValidatorMissedBlocks, 0)
-	keeper.IterateValidatorSigningInfos(ctx, func(address sdk.ConsAddress, info types.ValidatorSigningInfo) (stop bool) {
+	err = keeper.IterateValidatorSigningInfos(ctx, func(address sdk.ConsAddress, info types.ValidatorSigningInfo) (stop bool) {
 		bechAddr := address.String()
 		signingInfos = append(signingInfos, types.SigningInfo{
 			Address:              bechAddr,
@@ -76,6 +85,8 @@ func (keeper Keeper) ExportGenesis(ctx sdk.Context) (data *types.GenesisState) {
 
 		return false
 	})
-
+	if err != nil {
+		panic(err)
+	}
 	return types.NewGenesisState(params, signingInfos, missedBlocks)
 }
diff --git a/x/slashing/keeper/genesis_test.go b/x/slashing/keeper/genesis_test.go
index 84d5078c7b3..cde4bef704e 100644
--- a/x/slashing/keeper/genesis_test.go
+++ b/x/slashing/keeper/genesis_test.go
@@ -13,9 +13,8 @@ import (
 func (s *KeeperTestSuite) TestExportAndInitGenesis() {
 	ctx, keeper := s.ctx, s.slashingKeeper
 	require := s.Require()
-
-	keeper.Params.Set(ctx, testutil.TestParams())
-
+	err := keeper.Params.Set(ctx, testutil.TestParams())
+	s.Require().NoError(err)
 	consAddr1 := sdk.ConsAddress(sdk.AccAddress([]byte("addr1_______________")))
 	consAddr2 := sdk.ConsAddress(sdk.AccAddress([]byte("addr2_______________")))
 
@@ -24,8 +23,8 @@ func (s *KeeperTestSuite) TestExportAndInitGenesis() {
 	info2 := types.NewValidatorSigningInfo(consAddr2, int64(5), int64(4),
 		time.Now().UTC().Add(10000000000), false, int64(10))
 
-	keeper.SetValidatorSigningInfo(ctx, consAddr1, info1)
-	keeper.SetValidatorSigningInfo(ctx, consAddr2, info2)
+	s.Require().NoError(keeper.SetValidatorSigningInfo(ctx, consAddr1, info1))
+	s.Require().NoError(keeper.SetValidatorSigningInfo(ctx, consAddr2, info2))
 	genesisState := keeper.ExportGenesis(ctx)
 
 	require.Equal(genesisState.Params, testutil.TestParams())
@@ -33,7 +32,7 @@ func (s *KeeperTestSuite) TestExportAndInitGenesis() {
 	require.Equal(genesisState.SigningInfos[0].ValidatorSigningInfo, info1)
 
 	// Tombstone validators after genesis shouldn't effect genesis state
-	err := keeper.Tombstone(ctx, consAddr1)
+	err = keeper.Tombstone(ctx, consAddr1)
 	require.NoError(err)
 	err = keeper.Tombstone(ctx, consAddr2)
 	require.NoError(err)
diff --git a/x/slashing/keeper/grpc_query_test.go b/x/slashing/keeper/grpc_query_test.go
index 8048c85bec0..a9d80da510a 100644
--- a/x/slashing/keeper/grpc_query_test.go
+++ b/x/slashing/keeper/grpc_query_test.go
@@ -38,7 +38,7 @@ func (s *KeeperTestSuite) TestGRPCSigningInfo() {
 		int64(0),
 	)
 
-	keeper.SetValidatorSigningInfo(ctx, consAddr, signingInfo)
+	require.NoError(keeper.SetValidatorSigningInfo(ctx, consAddr, signingInfo))
 	info, err := keeper.GetValidatorSigningInfo(ctx, consAddr)
 	require.NoError(err)
 
@@ -64,17 +64,16 @@ func (s *KeeperTestSuite) TestGRPCSigningInfos() {
 		int64(0),
 	)
 
-	keeper.SetValidatorSigningInfo(ctx, consAddr1, signingInfo)
+	require.NoError(keeper.SetValidatorSigningInfo(ctx, consAddr1, signingInfo))
 	signingInfo.Address = string(consAddr2)
-	keeper.SetValidatorSigningInfo(ctx, consAddr2, signingInfo)
-
+	require.NoError(keeper.SetValidatorSigningInfo(ctx, consAddr2, signingInfo))
 	var signingInfos []slashingtypes.ValidatorSigningInfo
 
-	keeper.IterateValidatorSigningInfos(ctx, func(consAddr sdk.ConsAddress, info slashingtypes.ValidatorSigningInfo) (stop bool) {
+	err := keeper.IterateValidatorSigningInfos(ctx, func(consAddr sdk.ConsAddress, info slashingtypes.ValidatorSigningInfo) (stop bool) {
 		signingInfos = append(signingInfos, info)
 		return false
 	})
-
+	require.NoError(err)
 	// verify all values are returned without pagination
 	infoResp, err := queryClient.SigningInfos(gocontext.Background(),
 		&slashingtypes.QuerySigningInfosRequest{Pagination: nil})
diff --git a/x/slashing/keeper/hooks_test.go b/x/slashing/keeper/hooks_test.go
index 35d39998160..f1aa3bcddee 100644
--- a/x/slashing/keeper/hooks_test.go
+++ b/x/slashing/keeper/hooks_test.go
@@ -11,9 +11,9 @@ func (s *KeeperTestSuite) TestAfterValidatorBonded() {
 	require := s.Require()
 
 	valAddr := sdk.ValAddress(consAddr.Bytes())
-	keeper.Hooks().AfterValidatorBonded(ctx, consAddr, valAddr)
-
-	_, err := keeper.GetValidatorSigningInfo(ctx, consAddr)
+	err := keeper.Hooks().AfterValidatorBonded(ctx, consAddr, valAddr)
+	require.NoError(err)
+	_, err = keeper.GetValidatorSigningInfo(ctx, consAddr)
 	require.NoError(err)
 }
 
diff --git a/x/slashing/keeper/infractions.go b/x/slashing/keeper/infractions.go
index 003963069f7..0efef7dd427 100644
--- a/x/slashing/keeper/infractions.go
+++ b/x/slashing/keeper/infractions.go
@@ -144,8 +144,10 @@ func (k Keeper) HandleValidatorSignature(ctx context.Context, addr cryptotypes.A
 					sdk.NewAttribute(types.AttributeKeyBurnedCoins, coinsBurned.String()),
 				),
 			)
-			k.sk.Jail(sdkCtx, consAddr)
-
+			err = k.sk.Jail(sdkCtx, consAddr)
+			if err != nil {
+				return err
+			}
 			downtimeJailDur, err := k.DowntimeJailDuration(ctx)
 			if err != nil {
 				return err
diff --git a/x/slashing/keeper/keeper.go b/x/slashing/keeper/keeper.go
index ef12b639e07..31e82a73c80 100644
--- a/x/slashing/keeper/keeper.go
+++ b/x/slashing/keeper/keeper.go
@@ -125,7 +125,10 @@ func (k Keeper) SlashWithInfractionReason(ctx context.Context, consAddr sdk.Cons
 // to make the necessary validator changes.
 func (k Keeper) Jail(ctx context.Context, consAddr sdk.ConsAddress) error {
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
-	k.sk.Jail(sdkCtx, consAddr)
+	err := k.sk.Jail(sdkCtx, consAddr)
+	if err != nil {
+		return err
+	}
 	sdkCtx.EventManager().EmitEvent(
 		sdk.NewEvent(
 			types.EventTypeSlash,
diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go
index 339d368b2dd..ac8a6d441d8 100644
--- a/x/slashing/keeper/keeper_test.go
+++ b/x/slashing/keeper/keeper_test.go
@@ -57,8 +57,8 @@ func (s *KeeperTestSuite) SetupTest() {
 		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
 	)
 	// set test params
-	s.slashingKeeper.Params.Set(ctx, slashingtestutil.TestParams())
-
+	err := s.slashingKeeper.Params.Set(ctx, slashingtestutil.TestParams())
+	s.Require().NoError(err)
 	slashingtypes.RegisterInterfaces(encCfg.InterfaceRegistry)
 	queryHelper := baseapp.NewQueryServerTestHelper(ctx, encCfg.InterfaceRegistry)
 	slashingtypes.RegisterQueryServer(queryHelper, slashingkeeper.NewQuerier(s.slashingKeeper))
@@ -91,16 +91,16 @@ func (s *KeeperTestSuite) TestJailAndSlash() {
 		stakingtypes.Infraction_INFRACTION_UNSPECIFIED,
 	).Return(sdkmath.NewInt(0), nil)
 
-	s.slashingKeeper.Slash(
+	err = s.slashingKeeper.Slash(
 		s.ctx,
 		consAddr,
 		slashFractionDoubleSign,
 		sdk.TokensToConsensusPower(sdkmath.NewInt(1), sdk.DefaultPowerReduction),
 		s.ctx.BlockHeight(),
 	)
-
+	s.Require().NoError(err)
 	s.stakingKeeper.EXPECT().Jail(s.ctx, consAddr).Return(nil)
-	s.slashingKeeper.Jail(s.ctx, consAddr)
+	s.Require().NoError(s.slashingKeeper.Jail(s.ctx, consAddr))
 }
 
 func (s *KeeperTestSuite) TestJailAndSlashWithInfractionReason() {
@@ -115,7 +115,7 @@ func (s *KeeperTestSuite) TestJailAndSlashWithInfractionReason() {
 		stakingtypes.Infraction_INFRACTION_DOUBLE_SIGN,
 	).Return(sdkmath.NewInt(0), nil)
 
-	s.slashingKeeper.SlashWithInfractionReason(
+	err = s.slashingKeeper.SlashWithInfractionReason(
 		s.ctx,
 		consAddr,
 		slashFractionDoubleSign,
@@ -123,9 +123,9 @@ func (s *KeeperTestSuite) TestJailAndSlashWithInfractionReason() {
 		s.ctx.BlockHeight(),
 		stakingtypes.Infraction_INFRACTION_DOUBLE_SIGN,
 	)
-
+	s.Require().NoError(err)
 	s.stakingKeeper.EXPECT().Jail(s.ctx, consAddr).Return(nil)
-	s.slashingKeeper.Jail(s.ctx, consAddr)
+	s.Require().NoError(s.slashingKeeper.Jail(s.ctx, consAddr))
 }
 
 func TestKeeperTestSuite(t *testing.T) {
diff --git a/x/slashing/keeper/msg_server_test.go b/x/slashing/keeper/msg_server_test.go
index 29f066acf01..271763e254b 100644
--- a/x/slashing/keeper/msg_server_test.go
+++ b/x/slashing/keeper/msg_server_test.go
@@ -211,8 +211,7 @@ func (s *KeeperTestSuite) TestUnjail() {
 				info := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addr), int64(4), int64(3),
 					time.Unix(2, 0), false, int64(10))
 
-				s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info)
-
+				s.Require().NoError(s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info))
 				s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val, nil)
 				del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(100))
 
@@ -241,8 +240,7 @@ func (s *KeeperTestSuite) TestUnjail() {
 				info := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addr), int64(4), int64(3),
 					time.Unix(2, 0), true, int64(10))
 
-				s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info)
-
+				s.Require().NoError(s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info))
 				s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val, nil)
 				del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(100))
 
@@ -271,8 +269,7 @@ func (s *KeeperTestSuite) TestUnjail() {
 				info := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addr), int64(4), int64(3),
 					s.ctx.BlockTime().AddDate(0, 0, 1), false, int64(10))
 
-				s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info)
-
+				s.Require().NoError(s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info))
 				s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val, nil)
 				del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(10000))
 
@@ -301,8 +298,7 @@ func (s *KeeperTestSuite) TestUnjail() {
 				info := slashingtypes.NewValidatorSigningInfo(sdk.ConsAddress(addr), int64(4), int64(3),
 					time.Unix(2, 0), false, int64(10))
 
-				s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info)
-
+				s.Require().NoError(s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info))
 				s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val, nil)
 				del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(100))
 
diff --git a/x/slashing/keeper/signing_info.go b/x/slashing/keeper/signing_info.go
index 97e85f4cab1..f4e1fe94f3a 100644
--- a/x/slashing/keeper/signing_info.go
+++ b/x/slashing/keeper/signing_info.go
@@ -193,8 +193,7 @@ func (k Keeper) SetMissedBlockBitmapValue(ctx context.Context, addr sdk.ConsAddr
 		return errors.Wrapf(err, "failed to encode bitmap chunk; index: %d", index)
 	}
 
-	k.setMissedBlockBitmapChunk(ctx, addr, chunkIndex, updatedChunk)
-	return nil
+	return k.setMissedBlockBitmapChunk(ctx, addr, chunkIndex, updatedChunk)
 }
 
 // DeleteMissedBlockBitmap removes a validator's missed block bitmap from state.
diff --git a/x/slashing/keeper/signing_info_test.go b/x/slashing/keeper/signing_info_test.go
index 14b7221bf2c..c2e3a69f97f 100644
--- a/x/slashing/keeper/signing_info_test.go
+++ b/x/slashing/keeper/signing_info_test.go
@@ -22,8 +22,7 @@ func (s *KeeperTestSuite) TestValidatorSigningInfo() {
 	)
 
 	// set the validator signing information
-	keeper.SetValidatorSigningInfo(ctx, consAddr, signingInfo)
-
+	require.NoError(keeper.SetValidatorSigningInfo(ctx, consAddr, signingInfo))
 	require.True(keeper.HasValidatorSigningInfo(ctx, consAddr))
 	info, err := keeper.GetValidatorSigningInfo(ctx, consAddr)
 	require.NoError(err)
@@ -34,11 +33,11 @@ func (s *KeeperTestSuite) TestValidatorSigningInfo() {
 
 	var signingInfos []slashingtypes.ValidatorSigningInfo
 
-	keeper.IterateValidatorSigningInfos(ctx, func(consAddr sdk.ConsAddress, info slashingtypes.ValidatorSigningInfo) (stop bool) {
+	err = keeper.IterateValidatorSigningInfos(ctx, func(consAddr sdk.ConsAddress, info slashingtypes.ValidatorSigningInfo) (stop bool) {
 		signingInfos = append(signingInfos, info)
 		return false
 	})
-
+	require.NoError(err)
 	require.Equal(signingInfos[0].Address, signingInfo.Address)
 
 	// test Tombstone
@@ -48,7 +47,7 @@ func (s *KeeperTestSuite) TestValidatorSigningInfo() {
 
 	// test JailUntil
 	jailTime := time.Now().Add(time.Hour).UTC()
-	keeper.JailUntil(ctx, consAddr, jailTime)
+	require.NoError(keeper.JailUntil(ctx, consAddr, jailTime))
 	sInfo, _ := keeper.GetValidatorSigningInfo(ctx, consAddr)
 	require.Equal(sInfo.JailedUntil, jailTime)
 }
diff --git a/x/slashing/simulation/operations_test.go b/x/slashing/simulation/operations_test.go
index 33c98280541..1963b6dd805 100644
--- a/x/slashing/simulation/operations_test.go
+++ b/x/slashing/simulation/operations_test.go
@@ -114,7 +114,6 @@ func (suite *SimTestSuite) SetupTest() {
 		suite.accountKeeper.SetAccount(suite.ctx, acc)
 		suite.Require().NoError(banktestutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
 	}
-
 	suite.Require().NoError(suite.mintKeeper.Params.Set(suite.ctx, minttypes.DefaultParams()))
 	suite.Require().NoError(suite.mintKeeper.Minter.Set(suite.ctx, minttypes.DefaultInitialMinter()))
 }
@@ -161,15 +160,17 @@ func (suite *SimTestSuite) TestSimulateMsgUnjail() {
 	suite.Require().NoError(err)
 
 	// setup validator0 by consensus address
-	suite.stakingKeeper.SetValidatorByConsAddr(ctx, validator0)
+	err = suite.stakingKeeper.SetValidatorByConsAddr(ctx, validator0)
+	suite.Require().NoError(err)
+
 	val0ConsAddress, err := validator0.GetConsAddr()
 	suite.Require().NoError(err)
 	info := types.NewValidatorSigningInfo(val0ConsAddress, int64(4), int64(3),
 		time.Unix(2, 0), false, int64(10))
-	suite.slashingKeeper.SetValidatorSigningInfo(ctx, val0ConsAddress, info)
-
+	err = suite.slashingKeeper.SetValidatorSigningInfo(ctx, val0ConsAddress, info)
+	suite.Require().NoError(err)
 	// put validator0 in jail
-	suite.stakingKeeper.Jail(ctx, val0ConsAddress)
+	suite.Require().NoError(suite.stakingKeeper.Jail(ctx, val0ConsAddress))
 
 	// setup self delegation
 	delTokens := suite.stakingKeeper.TokensFromConsensusPower(ctx, 2)
@@ -177,7 +178,7 @@ func (suite *SimTestSuite) TestSimulateMsgUnjail() {
 	val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress)
 	suite.Require().NoError(err)
 	selfDelegation := stakingtypes.NewDelegation(val0AccAddress.Bytes(), validator0.GetOperator(), issuedShares)
-	suite.stakingKeeper.SetDelegation(ctx, selfDelegation)
+	suite.Require().NoError(suite.stakingKeeper.SetDelegation(ctx, selfDelegation))
 	suite.Require().NoError(suite.distrKeeper.DelegatorStartingInfo.Set(ctx, collections.Join(validator0.GetOperator(), sdk.AccAddress(val0AccAddress)), distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 200)))
 
 	// begin a new block
@@ -218,7 +219,9 @@ func getTestingValidator(ctx sdk.Context, stakingKeeper *stakingkeeper.Keeper, a
 	validator.DelegatorShares = math.LegacyNewDec(100)
 	validator.Tokens = math.NewInt(1000000)
 
-	stakingKeeper.SetValidator(ctx, validator)
-
+	err = stakingKeeper.SetValidator(ctx, validator)
+	if err != nil {
+		return stakingtypes.Validator{}, err
+	}
 	return validator, nil
 }
diff --git a/x/upgrade/abci_test.go b/x/upgrade/abci_test.go
index a1051a72dcb..845694a7d24 100644
--- a/x/upgrade/abci_test.go
+++ b/x/upgrade/abci_test.go
@@ -167,7 +167,6 @@ func TestHaltIfTooNew(t *testing.T) {
 	})
 
 	newCtx := s.ctx.WithHeaderInfo(header.Info{Height: s.ctx.HeaderInfo().Height + 1, Time: time.Now()})
-
 	err := s.module.BeginBlock(newCtx)
 	require.NoError(t, err)
 	require.Equal(t, 0, called)
@@ -175,7 +174,6 @@ func TestHaltIfTooNew(t *testing.T) {
 	t.Log("Verify we error if we have a registered handler ahead of time")
 	err = s.keeper.ScheduleUpgrade(s.ctx, types.Plan{Name: "future", Height: s.ctx.HeaderInfo().Height + 3})
 	require.NoError(t, err)
-
 	err = s.module.BeginBlock(newCtx)
 	require.EqualError(t, err, "BINARY UPDATED BEFORE TRIGGER! UPGRADE \"future\" - in binary but not executed on chain. Downgrade your binary")
 	require.Equal(t, 0, called)
@@ -351,7 +349,6 @@ func TestUpgradeWithoutSkip(t *testing.T) {
 	err := s.keeper.ScheduleUpgrade(s.ctx, types.Plan{Name: "test", Height: s.ctx.HeaderInfo().Height + 1})
 	require.NoError(t, err)
 	t.Log("Verify if upgrade happens without skip upgrade")
-
 	err = s.module.BeginBlock(newCtx)
 	require.ErrorContains(t, err, "UPGRADE \"test\" NEEDED at height:")
 
@@ -418,11 +415,11 @@ func TestBinaryVersion(t *testing.T) {
 				require.NoError(t, err)
 
 				newCtx := s.ctx.WithHeaderInfo(header.Info{Height: 12})
-				s.keeper.ApplyUpgrade(newCtx, types.Plan{
+				err = s.keeper.ApplyUpgrade(newCtx, types.Plan{
 					Name:   "test0",
 					Height: 12,
 				})
-
+				require.NoError(t, err)
 				return newCtx
 			},
 			false,
diff --git a/x/upgrade/client/cli/parse_test.go b/x/upgrade/client/cli/parse_test.go
index d1869f24c2d..cb58c1e0a22 100644
--- a/x/upgrade/client/cli/parse_test.go
+++ b/x/upgrade/client/cli/parse_test.go
@@ -22,8 +22,11 @@ func TestParsePlan(t *testing.T) {
 		},
 	}
 
-	fs.Set(FlagUpgradeHeight, strconv.FormatInt(proposal.Plan.Height, 10))
-	fs.Set(FlagUpgradeInfo, proposal.Plan.Info)
+	err := fs.Set(FlagUpgradeHeight, strconv.FormatInt(proposal.Plan.Height, 10))
+	require.NoError(t, err)
+
+	err = fs.Set(FlagUpgradeInfo, proposal.Plan.Info)
+	require.NoError(t, err)
 
 	p, err := parsePlan(fs, proposal.Plan.Name)
 	require.NoError(t, err)
diff --git a/x/upgrade/client/cli/tx.go b/x/upgrade/client/cli/tx.go
index 294538fdc6d..ab74e5d3e2e 100644
--- a/x/upgrade/client/cli/tx.go
+++ b/x/upgrade/client/cli/tx.go
@@ -127,7 +127,10 @@ func NewCmdSubmitUpgradeProposal(ac addresscodec.Codec) *cobra.Command {
 	// add common proposal flags
 	flags.AddTxFlagsToCmd(cmd)
 	cli.AddGovPropFlagsToCmd(cmd)
-	cmd.MarkFlagRequired(cli.FlagTitle)
+	err := cmd.MarkFlagRequired(cli.FlagTitle)
+	if err != nil {
+		panic(err)
+	}
 
 	return cmd
 }
@@ -176,7 +179,10 @@ func NewCmdSubmitCancelUpgradeProposal(ac addresscodec.Codec) *cobra.Command {
 	// add common proposal flags
 	flags.AddTxFlagsToCmd(cmd)
 	cli.AddGovPropFlagsToCmd(cmd)
-	cmd.MarkFlagRequired(cli.FlagTitle)
+	err := cmd.MarkFlagRequired(cli.FlagTitle)
+	if err != nil {
+		panic(err)
+	}
 
 	return cmd
 }
diff --git a/x/upgrade/keeper/grpc_query_test.go b/x/upgrade/keeper/grpc_query_test.go
index 3217cce1117..bb2eab17bd2 100644
--- a/x/upgrade/keeper/grpc_query_test.go
+++ b/x/upgrade/keeper/grpc_query_test.go
@@ -42,10 +42,10 @@ func (suite *UpgradeTestSuite) SetupTest() {
 	skipUpgradeHeights := make(map[int64]bool)
 
 	suite.upgradeKeeper = keeper.NewKeeper(skipUpgradeHeights, storeService, suite.encCfg.Codec, suite.T().TempDir(), nil, authtypes.NewModuleAddress(govtypes.ModuleName).String())
-	suite.upgradeKeeper.SetModuleVersionMap(suite.ctx, module.VersionMap{
+	err := suite.upgradeKeeper.SetModuleVersionMap(suite.ctx, module.VersionMap{
 		"bank": 0,
 	})
-
+	suite.Require().NoError(err)
 	queryHelper := baseapp.NewQueryServerTestHelper(testCtx.Ctx, suite.encCfg.InterfaceRegistry)
 	types.RegisterQueryServer(queryHelper, suite.upgradeKeeper)
 	suite.queryClient = types.NewQueryClient(queryHelper)
@@ -74,8 +74,8 @@ func (suite *UpgradeTestSuite) TestQueryCurrentPlan() {
 			"with current upgrade plan",
 			func() {
 				plan := types.Plan{Name: "test-plan", Height: 5}
-				suite.upgradeKeeper.ScheduleUpgrade(suite.ctx, plan)
-
+				err := suite.upgradeKeeper.ScheduleUpgrade(suite.ctx, plan)
+				suite.Require().NoError(err)
 				req = &types.QueryCurrentPlanRequest{}
 				expResponse = types.QueryCurrentPlanResponse{Plan: &plan}
 			},
@@ -127,14 +127,14 @@ func (suite *UpgradeTestSuite) TestAppliedCurrentPlan() {
 
 				planName := "test-plan"
 				plan := types.Plan{Name: planName, Height: expHeight}
-				suite.upgradeKeeper.ScheduleUpgrade(suite.ctx, plan)
-
+				err := suite.upgradeKeeper.ScheduleUpgrade(suite.ctx, plan)
+				suite.Require().NoError(err)
 				suite.ctx = suite.ctx.WithHeaderInfo(header.Info{Height: expHeight})
 				suite.upgradeKeeper.SetUpgradeHandler(planName, func(ctx context.Context, plan types.Plan, vm module.VersionMap) (module.VersionMap, error) {
 					return vm, nil
 				})
-				suite.upgradeKeeper.ApplyUpgrade(suite.ctx, plan)
-
+				err = suite.upgradeKeeper.ApplyUpgrade(suite.ctx, plan)
+				suite.Require().NoError(err)
 				req = &types.QueryAppliedPlanRequest{Name: planName}
 			},
 			true,
diff --git a/x/upgrade/keeper/keeper_test.go b/x/upgrade/keeper/keeper_test.go
index 2f08536ec50..ffa0692fff8 100644
--- a/x/upgrade/keeper/keeper_test.go
+++ b/x/upgrade/keeper/keeper_test.go
@@ -115,11 +115,12 @@ func (s *KeeperTestSuite) TestScheduleUpgrade() {
 				Height: 123450000,
 			},
 			setup: func() {
-				s.upgradeKeeper.ScheduleUpgrade(s.ctx, types.Plan{
+				err := s.upgradeKeeper.ScheduleUpgrade(s.ctx, types.Plan{
 					Name:   "alt-good",
 					Info:   "new text here",
 					Height: 543210000,
 				})
+				s.Require().NoError(err)
 			},
 			expPass: true,
 		},
@@ -152,11 +153,12 @@ func (s *KeeperTestSuite) TestScheduleUpgrade() {
 				s.upgradeKeeper.SetUpgradeHandler("all-good", func(ctx context.Context, plan types.Plan, vm module.VersionMap) (module.VersionMap, error) {
 					return vm, nil
 				})
-				s.upgradeKeeper.ApplyUpgrade(s.ctx, types.Plan{
+				err := s.upgradeKeeper.ApplyUpgrade(s.ctx, types.Plan{
 					Name:   "all-good",
 					Info:   "some text here",
 					Height: 123450000,
 				})
+				s.Require().NoError(err)
 			},
 			expPass: false,
 		},
@@ -202,7 +204,8 @@ func (s *KeeperTestSuite) TestSetUpgradedClient() {
 			name:   "success",
 			height: 10,
 			setup: func() {
-				s.upgradeKeeper.SetUpgradedClient(s.ctx, 10, cs)
+				err := s.upgradeKeeper.SetUpgradedClient(s.ctx, 10, cs)
+				s.Require().NoError(err)
 			},
 			exists: true,
 		},
@@ -269,7 +272,8 @@ func (s *KeeperTestSuite) TestIncrementProtocolVersion() {
 	s.Require().EqualError(err, "ApplyUpgrade should never be called without first checking HasHandler")
 
 	s.upgradeKeeper.SetUpgradeHandler("dummy", func(_ context.Context, _ types.Plan, vm module.VersionMap) (module.VersionMap, error) { return vm, nil })
-	s.upgradeKeeper.ApplyUpgrade(s.ctx, dummyPlan)
+	err = s.upgradeKeeper.ApplyUpgrade(s.ctx, dummyPlan)
+	s.Require().NoError(err)
 	upgradedProtocolVersion := s.baseApp.AppVersion()
 
 	s.Require().Equal(oldProtocolVersion+1, upgradedProtocolVersion)
@@ -279,7 +283,8 @@ func (s *KeeperTestSuite) TestIncrementProtocolVersion() {
 // an upgrade.
 func (s *KeeperTestSuite) TestMigrations() {
 	initialVM := module.VersionMap{"bank": uint64(1)}
-	s.upgradeKeeper.SetModuleVersionMap(s.ctx, initialVM)
+	err := s.upgradeKeeper.SetModuleVersionMap(s.ctx, initialVM)
+	s.Require().NoError(err)
 	vmBefore, err := s.upgradeKeeper.GetModuleVersionMap(s.ctx)
 	s.Require().NoError(err)
 
@@ -294,7 +299,8 @@ func (s *KeeperTestSuite) TestMigrations() {
 		Height: 123450000,
 	}
 
-	s.upgradeKeeper.ApplyUpgrade(s.ctx, dummyPlan)
+	err = s.upgradeKeeper.ApplyUpgrade(s.ctx, dummyPlan)
+	s.Require().NoError(err)
 	vm, err := s.upgradeKeeper.GetModuleVersionMap(s.ctx)
 	s.Require().Equal(vmBefore["bank"]+1, vm["bank"])
 	s.Require().NoError(err)
@@ -314,11 +320,11 @@ func (s *KeeperTestSuite) TestLastCompletedUpgrade() {
 		return vm, nil
 	})
 
-	keeper.ApplyUpgrade(s.ctx, types.Plan{
+	err = keeper.ApplyUpgrade(s.ctx, types.Plan{
 		Name:   "test0",
 		Height: 10,
 	})
-
+	require.NoError(err)
 	s.T().Log("verify valid upgrade name and height")
 	name, height, err = keeper.GetLastCompletedUpgrade(s.ctx)
 	require.Equal("test0", name)
@@ -330,11 +336,11 @@ func (s *KeeperTestSuite) TestLastCompletedUpgrade() {
 	})
 
 	newCtx := s.ctx.WithHeaderInfo(header.Info{Height: 15})
-	keeper.ApplyUpgrade(newCtx, types.Plan{
+	err = keeper.ApplyUpgrade(newCtx, types.Plan{
 		Name:   "test1",
 		Height: 15,
 	})
-
+	require.NoError(err)
 	s.T().Log("verify valid upgrade name and height with multiple upgrades")
 	name, height, err = keeper.GetLastCompletedUpgrade(newCtx)
 	require.Equal("test1", name)
@@ -353,11 +359,11 @@ func (s *KeeperTestSuite) TestLastCompletedUpgradeOrdering() {
 		return vm, nil
 	})
 
-	keeper.ApplyUpgrade(s.ctx, types.Plan{
+	err := keeper.ApplyUpgrade(s.ctx, types.Plan{
 		Name:   "test-v0.9",
 		Height: 10,
 	})
-
+	require.NoError(err)
 	name, height, err := keeper.GetLastCompletedUpgrade(s.ctx)
 	require.Equal("test-v0.9", name)
 	require.Equal(int64(10), height)
diff --git a/x/upgrade/types/storeloader_test.go b/x/upgrade/types/storeloader_test.go
index be18a05708f..5f0ab0ecd6d 100644
--- a/x/upgrade/types/storeloader_test.go
+++ b/x/upgrade/types/storeloader_test.go
@@ -128,8 +128,9 @@ func TestSetLoader(t *testing.T) {
 			require.Equal(t, int64(1), oldApp.LastBlockHeight())
 
 			for i := int64(2); i <= upgradeHeight-1; i++ {
-				oldApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: i})
-				_, err := oldApp.Commit()
+				_, err := oldApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: i})
+				require.NoError(t, err)
+				_, err = oldApp.Commit()
 				require.NoError(t, err)
 			}
 
@@ -149,7 +150,8 @@ func TestSetLoader(t *testing.T) {
 			require.Equal(t, upgradeHeight-1, newApp.LastBlockHeight())
 
 			// "execute" one block
-			newApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: upgradeHeight})
+			_, err = newApp.FinalizeBlock(&abci.RequestFinalizeBlock{Height: upgradeHeight})
+			require.NoError(t, err)
 			_, err = newApp.Commit()
 			require.NoError(t, err)
 			require.Equal(t, upgradeHeight, newApp.LastBlockHeight())