approval-voting improvement: include all tranche0 assignments in one certificate (#1178)

**_PR migrated from https://github.com/paritytech/polkadot/pull/6782_** 

This PR will upgrade the network protocol to version 3 -> VStaging which
will later be renamed to V3. This version introduces a new kind of
assignment certificate that will be used for tranche0 assignments.
Instead of issuing/importing one tranche0 assignment per candidate,
there will be just one certificate per relay chain block per validator.
However, we will not be sending out the new assignment certificates,
yet. So everything should work exactly as before. Once the majority of
the validators have been upgraded to the new protocol version we will
enable the new certificates (starting at a specific relay chain block)
with a new client update.

There are still a few things that need to be done:

- [x] Use bitfield instead of Vec<CandidateIndex>:
https://github.com/paritytech/polkadot/pull/6802
  - [x] Fix existing approval-distribution and approval-voting tests
  - [x] Fix bitfield-distribution and statement-distribution tests
  - [x] Fix network bridge tests
  - [x] Implement todos in the code
  - [x] Add tests to cover new code
  - [x] Update metrics
  - [x] Remove the approval distribution aggression levels: TBD PR
  - [x] Parachains DB migration 
  - [x] Test network protocol upgrade on Versi
  - [x] Versi Load test
  - [x] Add Zombienet test
  - [x] Documentation updates
- [x] Fix for sending DistributeAssignment for each candidate claimed by
a v2 assignment (warning: Importing locally an already known assignment)
 - [x]  Fix AcceptedDuplicate
 - [x] Fix DB migration so that we can still keep old data.
 - [x] Final Versi burn in

---------

Signed-off-by: Andrei Sandu <andrei-mihail@parity.io>
Signed-off-by: Alexandru Gheorghe <alexandru.gheorghe@parity.io>
Co-authored-by: Alexandru Gheorghe <alexandru.gheorghe@parity.io>

polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
+use net_protocol::{filter_by_peer_version, peer_set::ProtocolVersion};
 use parity_scale_codec::Encode;
 
 use polkadot_node_network_protocol::{
@@ -21,7 +22,8 @@ use polkadot_node_network_protocol::{
 	grid_topology::{GridNeighbors, RequiredRouting, SessionBoundGridTopologyStorage},
 	peer_set::{IsAuthority, PeerSet, ValidationVersion},
 	v1::{self as protocol_v1, StatementMetadata},
-	v2 as protocol_v2, IfDisconnected, PeerId, UnifiedReputationChange as Rep, Versioned, View,
+	v2 as protocol_v2, vstaging as protocol_vstaging, IfDisconnected, PeerId,
+	UnifiedReputationChange as Rep, Versioned, View,
 };
 use polkadot_node_primitives::{
 	SignedFullStatement, Statement, StatementWithPVD, UncheckedSignedFullStatement,
@@ -1061,7 +1063,7 @@ async fn circulate_statement<'a, Context>(
 		"We filter out duplicates above. qed.",
 	);
 
-	let (v1_peers_to_send, v2_peers_to_send) = peers_to_send
+	let (v1_peers_to_send, non_v1_peers_to_send) = peers_to_send
 		.into_iter()
 		.map(|peer_id| {
 			let peer_data =
@@ -1073,7 +1075,7 @@ async fn circulate_statement<'a, Context>(
 		})
 		.partition::<Vec<_>, _>(|(_, _, version)| match version {
 			ValidationVersion::V1 => true,
-			ValidationVersion::V2 => false,
+			ValidationVersion::V2 | ValidationVersion::VStaging => false,
 		}); // partition is handy here but not if we add more protocol versions
 
 	let payload = v1_statement_message(relay_parent, stored.statement.clone(), metrics);
@@ -1093,6 +1095,22 @@ async fn circulate_statement<'a, Context>(
 		))
 		.await;
 	}
+
+	let peers_to_send: Vec<(PeerId, ProtocolVersion)> = non_v1_peers_to_send
+		.iter()
+		.map(|(p, _, version)| (*p, (*version).into()))
+		.collect();
+
+	let peer_needs_dependent_statement = v1_peers_to_send
+		.into_iter()
+		.chain(non_v1_peers_to_send)
+		.filter_map(|(peer, needs_dependent, _)| if needs_dependent { Some(peer) } else { None })
+		.collect();
+
+	let v2_peers_to_send = filter_by_peer_version(&peers_to_send, ValidationVersion::V2.into());
+	let vstaging_to_send =
+		filter_by_peer_version(&peers_to_send, ValidationVersion::VStaging.into());
+
 	if !v2_peers_to_send.is_empty() {
 		gum::trace!(
 			target: LOG_TARGET,
@@ -1102,17 +1120,28 @@ async fn circulate_statement<'a, Context>(
 			"Sending statement to v2 peers",
 		);
 		ctx.send_message(NetworkBridgeTxMessage::SendValidationMessage(
-			v2_peers_to_send.iter().map(|(p, _, _)| *p).collect(),
+			v2_peers_to_send,
 			compatible_v1_message(ValidationVersion::V2, payload.clone()).into(),
 		))
 		.await;
 	}
 
-	v1_peers_to_send
-		.into_iter()
-		.chain(v2_peers_to_send)
-		.filter_map(|(peer, needs_dependent, _)| if needs_dependent { Some(peer) } else { None })
-		.collect()
+	if !vstaging_to_send.is_empty() {
+		gum::trace!(
+			target: LOG_TARGET,
+			?vstaging_to_send,
+			?relay_parent,
+			statement = ?stored.statement,
+			"Sending statement to vstaging peers",
+		);
+		ctx.send_message(NetworkBridgeTxMessage::SendValidationMessage(
+			vstaging_to_send,
+			compatible_v1_message(ValidationVersion::VStaging, payload.clone()).into(),
+		))
+		.await;
+	}
+
+	peer_needs_dependent_statement
 }
 
 /// Send all statements about a given candidate hash to a peer.
@@ -1442,8 +1471,11 @@ async fn handle_incoming_message<'a, Context>(
 
 	let message = match message {
 		Versioned::V1(m) => m,
-		Versioned::V2(protocol_v2::StatementDistributionMessage::V1Compatibility(m)) => m,
-		Versioned::V2(_) => {
+		Versioned::V2(protocol_v2::StatementDistributionMessage::V1Compatibility(m)) |
+		Versioned::VStaging(protocol_vstaging::StatementDistributionMessage::V1Compatibility(
+			m,
+		)) => m,
+		Versioned::V2(_) | Versioned::VStaging(_) => {
 			// The higher-level subsystem code is supposed to filter out
 			// all non v1 messages.
 			gum::debug!(
@@ -2169,5 +2201,8 @@ fn compatible_v1_message(
 		ValidationVersion::V1 => Versioned::V1(message),
 		ValidationVersion::V2 =>
 			Versioned::V2(protocol_v2::StatementDistributionMessage::V1Compatibility(message)),
+		ValidationVersion::VStaging => Versioned::VStaging(
+			protocol_vstaging::StatementDistributionMessage::V1Compatibility(message),
+		),
 	}
 }