diff --git a/x/sequencers/keeper/msg_server_test.go b/x/sequencers/keeper/msg_server_test.go
index 5267a9b4..987a2350 100644
--- a/x/sequencers/keeper/msg_server_test.go
+++ b/x/sequencers/keeper/msg_server_test.go
@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
 
 	testkeepers "github.com/dymensionxyz/dymension-rdk/testutil/keepers"
@@ -12,7 +13,7 @@ import (
 	"github.com/dymensionxyz/dymension-rdk/x/sequencers/types"
 )
 
-func TestUpsertHappyPath(t *testing.T) {
+func TestHappyPath(t *testing.T) {
 	// prepare test
 	var (
 		app       = utils.Setup(t, false)
@@ -22,9 +23,15 @@ func TestUpsertHappyPath(t *testing.T) {
 
 	// prepare test data
 	var (
-		operator   = utils.Proposer.GetOperator()
-		rewardAddr = utils.AccAddress()
-		relayers   = []string{
+		operator    = utils.Proposer.GetOperator()
+		rewardAddr1 = utils.AccAddress()
+		rewardAddr2 = utils.AccAddress()
+		relayers1   = []string{
+			utils.AccAddress().String(),
+			utils.AccAddress().String(),
+			utils.AccAddress().String(),
+		}
+		relayers2 = []string{
 			utils.AccAddress().String(),
 			utils.AccAddress().String(),
 			utils.AccAddress().String(),
@@ -33,26 +40,76 @@ func TestUpsertHappyPath(t *testing.T) {
 	anyPubKey, err := codectypes.NewAnyWithValue(utils.ConsPrivKey.PubKey())
 	require.NoError(t, err)
 
-	msg := &types.ConsensusMsgUpsertSequencer{
-		Operator:   operator.String(),
-		ConsPubKey: anyPubKey,
-		RewardAddr: rewardAddr.String(),
-		Relayers:   relayers,
+	// helper method to validate test results
+	validateResults := func(rewardAddr string, relayers []string) {
+		// validate sequencer
+		actualSequencer, ok := app.SequencersKeeper.GetSequencer(ctx, operator)
+		require.True(t, ok)
+		consAddr, err := actualSequencer.GetConsAddr()
+		require.NoError(t, err)
+		require.Equal(t, consAddr, sdk.ConsAddress(utils.ConsPrivKey.PubKey().Address()))
+
+		// validate reward address
+		actualRewardAddr, ok := app.SequencersKeeper.GetRewardAddr(ctx, operator)
+		require.True(t, ok)
+		require.Equal(t, rewardAddr, actualRewardAddr.String())
+
+		// validate relayers
+		actualRelayers, err := app.SequencersKeeper.GetWhitelistedRelayers(ctx, operator)
+		require.NoError(t, err)
+		require.ElementsMatch(t, relayers, actualRelayers.Relayers)
 	}
 
-	err = msg.ValidateBasic()
-	require.NoError(t, err)
+	t.Run("ConsensusMsgUpsertSequencer", func(t *testing.T) {
+		msg := &types.ConsensusMsgUpsertSequencer{
+			Operator:   operator.String(),
+			ConsPubKey: anyPubKey,
+			RewardAddr: rewardAddr1.String(),
+			Relayers:   relayers1,
+		}
 
-	// call msg server
-	_, err = msgServer.UpsertSequencer(ctx, msg)
-	require.NoError(t, err)
+		err = msg.ValidateBasic()
+		require.NoError(t, err)
 
-	// validate results
-	actualRewardAddr, ok := app.SequencersKeeper.GetRewardAddr(ctx, operator)
-	require.True(t, ok)
-	require.Equal(t, msg.RewardAddr, actualRewardAddr.String())
+		// call msg server
+		_, err = msgServer.UpsertSequencer(ctx, msg)
+		require.NoError(t, err)
 
-	actualRelayers, err := app.SequencersKeeper.GetWhitelistedRelayers(ctx, operator)
-	require.NoError(t, err)
-	require.ElementsMatch(t, msg.Relayers, actualRelayers.Relayers)
+		// validate results
+		validateResults(rewardAddr1.String(), relayers1)
+	})
+
+	t.Run("MsgUpdateRewardAddress", func(t *testing.T) {
+		msg := &types.MsgUpdateRewardAddress{
+			Operator:   operator.String(),
+			RewardAddr: rewardAddr2.String(),
+		}
+
+		err = msg.ValidateBasic()
+		require.NoError(t, err)
+
+		// call msg server
+		_, err = msgServer.UpdateRewardAddress(ctx, msg)
+		require.NoError(t, err)
+
+		// validate results
+		validateResults(rewardAddr2.String(), relayers1)
+	})
+
+	t.Run("MsgUpdateWhitelistedRelayers", func(t *testing.T) {
+		msg := &types.MsgUpdateWhitelistedRelayers{
+			Operator: operator.String(),
+			Relayers: relayers2,
+		}
+
+		err = msg.ValidateBasic()
+		require.NoError(t, err)
+
+		// call msg server
+		_, err = msgServer.UpdateWhitelistedRelayers(ctx, msg)
+		require.NoError(t, err)
+
+		// validate results
+		validateResults(rewardAddr2.String(), relayers2)
+	})
 }
diff --git a/x/sequencers/types/msgs.go b/x/sequencers/types/msgs.go
index 25e4b5a5..6c16f2d0 100644
--- a/x/sequencers/types/msgs.go
+++ b/x/sequencers/types/msgs.go
@@ -23,11 +23,11 @@ var (
 func (m *MsgUpdateRewardAddress) ValidateBasic() error {
 	_, err := sdk.ValAddressFromBech32(m.GetOperator())
 	if err != nil {
-		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "acc addr")
+		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "get operator addr from bech32")
 	}
 	_, err = sdk.AccAddressFromBech32(m.RewardAddr)
 	if err != nil {
-		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "reward addr")
+		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "get reward addr from bech32")
 	}
 	return nil
 }
@@ -56,11 +56,11 @@ func (m *MsgUpdateRewardAddress) MustRewardAcc() sdk.AccAddress {
 func (m *MsgUpdateWhitelistedRelayers) ValidateBasic() error {
 	_, err := sdk.ValAddressFromBech32(m.GetOperator())
 	if err != nil {
-		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "acc addr")
+		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "get operator addr from bech32")
 	}
 	err = WhitelistedRelayers{Relayers: m.Relayers}.Validate()
 	if err != nil {
-		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "validate whitelisted relayer")
+		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "validate whitelisted relayers")
 	}
 	return nil
 }
@@ -110,7 +110,7 @@ func (m *ConsensusMsgUpsertSequencer) ValidateBasic() error {
 
 	err = WhitelistedRelayers{Relayers: m.Relayers}.Validate()
 	if err != nil {
-		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "validate whitelisted relayer")
+		return errorsmod.Wrap(errors.Join(gerrc.ErrInvalidArgument, err), "validate whitelisted relayers")
 	}
 
 	return nil
diff --git a/x/sequencers/types/msgs_test.go b/x/sequencers/types/msgs_test.go
index f6404c37..50039825 100644
--- a/x/sequencers/types/msgs_test.go
+++ b/x/sequencers/types/msgs_test.go
@@ -5,6 +5,7 @@ import (
 
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/dymensionxyz/gerr-cosmos/gerrc"
 	"github.com/stretchr/testify/require"
 
@@ -12,11 +13,131 @@ import (
 	"github.com/dymensionxyz/dymension-rdk/x/sequencers/types"
 )
 
+func TestMsgUpdateRewardAddress(t *testing.T) {
+	valAddr := sdk.ValAddress(utils.AccAddress())
+	rewardAddr := utils.AccAddress()
+
+	tests := []struct {
+		name          string
+		input         types.MsgUpdateRewardAddress
+		errorIs       error
+		errorContains string
+	}{
+		{
+			name: "valid",
+			input: types.MsgUpdateRewardAddress{
+				Operator:   valAddr.String(),
+				RewardAddr: rewardAddr.String(),
+			},
+			errorIs:       nil,
+			errorContains: "",
+		},
+		{
+			name: "invalid operator",
+			input: types.MsgUpdateRewardAddress{
+				Operator:   "invalid_operator",
+				RewardAddr: rewardAddr.String(),
+			},
+			errorIs:       gerrc.ErrInvalidArgument,
+			errorContains: "get operator addr from bech32",
+		},
+		{
+			name: "invalid reward addr",
+			input: types.MsgUpdateRewardAddress{
+				Operator:   valAddr.String(),
+				RewardAddr: "invalid_reward_addr",
+			},
+			errorIs:       gerrc.ErrInvalidArgument,
+			errorContains: "get reward addr from bech32",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.input.ValidateBasic()
+
+			expectError := tt.errorIs != nil
+			switch expectError {
+			case true:
+				require.Error(t, err)
+				require.ErrorIs(t, err, tt.errorIs)
+				require.Contains(t, err.Error(), tt.errorContains)
+			case false:
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestMsgUpdateWhitelistedRelayers(t *testing.T) {
+	valAddr := sdk.ValAddress(utils.AccAddress())
+	addr := utils.AccAddress()
+	relayers := []string{
+		utils.AccAddress().String(),
+		utils.AccAddress().String(),
+	}
+
+	tests := []struct {
+		name          string
+		input         types.MsgUpdateWhitelistedRelayers
+		errorIs       error
+		errorContains string
+	}{
+		{
+			name: "valid",
+			input: types.MsgUpdateWhitelistedRelayers{
+				Operator: valAddr.String(),
+				Relayers: relayers,
+			},
+			errorIs:       nil,
+			errorContains: "",
+		},
+		{
+			name: "invalid relayer addr",
+			input: types.MsgUpdateWhitelistedRelayers{
+				Operator: valAddr.String(),
+				Relayers: []string{"invalid"},
+			},
+			errorIs:       gerrc.ErrInvalidArgument,
+			errorContains: "validate whitelisted relayers",
+		},
+		{
+			name: "duplicated relayers",
+			input: types.MsgUpdateWhitelistedRelayers{
+				Operator: valAddr.String(),
+				Relayers: []string{addr.String(), addr.String()},
+			},
+			errorIs:       gerrc.ErrInvalidArgument,
+			errorContains: "validate whitelisted relayers",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.input.ValidateBasic()
+
+			expectError := tt.errorIs != nil
+			switch expectError {
+			case true:
+				require.Error(t, err)
+				require.ErrorIs(t, err, tt.errorIs)
+				require.Contains(t, err.Error(), tt.errorContains)
+			case false:
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
 func TestConsensusMsgUpsertSequencer(t *testing.T) {
 	valAddr := utils.AccAddress()
 	rewardAddr := utils.AccAddress()
 	anyPubKey, err := codectypes.NewAnyWithValue(ed25519.GenPrivKey().PubKey())
 	require.NoError(t, err)
+	relayers := []string{
+		utils.AccAddress().String(),
+		utils.AccAddress().String(),
+	}
 
 	tests := []struct {
 		name          string
@@ -30,6 +151,7 @@ func TestConsensusMsgUpsertSequencer(t *testing.T) {
 				Operator:   valAddr.String(),
 				ConsPubKey: anyPubKey,
 				RewardAddr: rewardAddr.String(),
+				Relayers:   relayers,
 			},
 			errorIs:       nil,
 			errorContains: "",
@@ -40,6 +162,7 @@ func TestConsensusMsgUpsertSequencer(t *testing.T) {
 				Operator:   valAddr.String(),
 				ConsPubKey: nil,
 				RewardAddr: rewardAddr.String(),
+				Relayers:   relayers,
 			},
 			errorIs:       gerrc.ErrInvalidArgument,
 			errorContains: "pub key is nil",
@@ -50,6 +173,7 @@ func TestConsensusMsgUpsertSequencer(t *testing.T) {
 				Operator:   "invalid_operator",
 				ConsPubKey: anyPubKey,
 				RewardAddr: rewardAddr.String(),
+				Relayers:   relayers,
 			},
 			errorIs:       gerrc.ErrInvalidArgument,
 			errorContains: "get operator addr from bech32",
@@ -60,10 +184,33 @@ func TestConsensusMsgUpsertSequencer(t *testing.T) {
 				Operator:   valAddr.String(),
 				ConsPubKey: anyPubKey,
 				RewardAddr: "invalid_reward_addr",
+				Relayers:   relayers,
 			},
 			errorIs:       gerrc.ErrInvalidArgument,
 			errorContains: "get reward addr from bech32",
 		},
+		{
+			name: "invalid relayer addr",
+			input: types.ConsensusMsgUpsertSequencer{
+				Operator:   valAddr.String(),
+				ConsPubKey: anyPubKey,
+				RewardAddr: rewardAddr.String(),
+				Relayers:   []string{"invalid"},
+			},
+			errorIs:       gerrc.ErrInvalidArgument,
+			errorContains: "validate whitelisted relayers",
+		},
+		{
+			name: "duplicated relayers",
+			input: types.ConsensusMsgUpsertSequencer{
+				Operator:   valAddr.String(),
+				ConsPubKey: anyPubKey,
+				RewardAddr: rewardAddr.String(),
+				Relayers:   []string{rewardAddr.String(), rewardAddr.String()},
+			},
+			errorIs:       gerrc.ErrInvalidArgument,
+			errorContains: "validate whitelisted relayers",
+		},
 	}
 
 	for _, tt := range tests {