Move block announcement protocol config out of Protocol (#12441)

* Move Role(s) to `sc-network-common`

* Introduce `NotificationHandshake` type

* Move block announce protocol config creation to `ChainSync`

* Include block announcement into `notification_protocols`

* Apply review comments

* Remove unneeded include

* Add missing include

* Apply review comments

substrate/client/network/common/src/protocol/event.rs

@@ -20,6 +20,7 @@
 //! events that happen on the network like DHT get/put results received.
 
 use super::ProtocolName;
+use crate::protocol::role::ObservedRole;
 use bytes::Bytes;
 use libp2p::{core::PeerId, kad::record::Key};
 
@@ -97,26 +98,3 @@ pub enum Event {
 		messages: Vec<(ProtocolName, Bytes)>,
 	},
 }
-
-/// Role that the peer sent to us during the handshake, with the addition of what our local node
-/// knows about that peer.
-///
-/// > **Note**: This enum is different from the `Role` enum. The `Role` enum indicates what a
-/// >			node says about itself, while `ObservedRole` is a `Role` merged with the
-/// >			information known locally about that node.
-#[derive(Debug, Clone)]
-pub enum ObservedRole {
-	/// Full node.
-	Full,
-	/// Light node.
-	Light,
-	/// Third-party authority.
-	Authority,
-}
-
-impl ObservedRole {
-	/// Returns `true` for `ObservedRole::Light`.
-	pub fn is_light(&self) -> bool {
-		matches!(self, Self::Light)
-	}
-}

substrate/client/network/common/src/protocol/role.rs

@@ -0,0 +1,121 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use codec::{self, Encode, EncodeLike, Input, Output};
+
+/// Role that the peer sent to us during the handshake, with the addition of what our local node
+/// knows about that peer.
+///
+/// > **Note**: This enum is different from the `Role` enum. The `Role` enum indicates what a
+/// >			node says about itself, while `ObservedRole` is a `Role` merged with the
+/// >			information known locally about that node.
+#[derive(Debug, Clone)]
+pub enum ObservedRole {
+	/// Full node.
+	Full,
+	/// Light node.
+	Light,
+	/// Third-party authority.
+	Authority,
+}
+
+impl ObservedRole {
+	/// Returns `true` for `ObservedRole::Light`.
+	pub fn is_light(&self) -> bool {
+		matches!(self, Self::Light)
+	}
+}
+
+/// Role of the local node.
+#[derive(Debug, Clone)]
+pub enum Role {
+	/// Regular full node.
+	Full,
+	/// Actual authority.
+	Authority,
+}
+
+impl Role {
+	/// True for [`Role::Authority`].
+	pub fn is_authority(&self) -> bool {
+		matches!(self, Self::Authority)
+	}
+}
+
+impl std::fmt::Display for Role {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Full => write!(f, "FULL"),
+			Self::Authority => write!(f, "AUTHORITY"),
+		}
+	}
+}
+
+bitflags::bitflags! {
+	/// Bitmask of the roles that a node fulfills.
+	pub struct Roles: u8 {
+		/// No network.
+		const NONE = 0b00000000;
+		/// Full node, does not participate in consensus.
+		const FULL = 0b00000001;
+		/// Light client node.
+		const LIGHT = 0b00000010;
+		/// Act as an authority
+		const AUTHORITY = 0b00000100;
+	}
+}
+
+impl Roles {
+	/// Does this role represents a client that holds full chain data locally?
+	pub fn is_full(&self) -> bool {
+		self.intersects(Self::FULL | Self::AUTHORITY)
+	}
+
+	/// Does this role represents a client that does not participates in the consensus?
+	pub fn is_authority(&self) -> bool {
+		*self == Self::AUTHORITY
+	}
+
+	/// Does this role represents a client that does not hold full chain data locally?
+	pub fn is_light(&self) -> bool {
+		!self.is_full()
+	}
+}
+
+impl<'a> From<&'a Role> for Roles {
+	fn from(roles: &'a Role) -> Self {
+		match roles {
+			Role::Full => Self::FULL,
+			Role::Authority => Self::AUTHORITY,
+		}
+	}
+}
+
+impl Encode for Roles {
+	fn encode_to<T: Output + ?Sized>(&self, dest: &mut T) {
+		dest.push_byte(self.bits())
+	}
+}
+
+impl EncodeLike for Roles {}
+
+impl codec::Decode for Roles {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		Self::from_bits(input.read_byte()?).ok_or_else(|| codec::Error::from("Invalid bytes"))
+	}
+}