Merge branch 'chore/upstream-cherry-picks' of ssh://github.com/plugblockchain/plug-blockchain into chore/upstream-cherry-picks

Author: jordy25519

Cargo.lock

@@ -102,13 +102,12 @@ pub enum Never {}
 ///
 /// # Examples
 ///
-/// ```
+/// ```no_compile
 /// # use frame_support::traits::Get;
 /// # use frame_support::parameter_types;
 /// // This function cannot be used in a const context.
 /// fn non_const_expression() -> u64 { 99 }
 ///
-/// ```no_compile
 /// parameter_types! {
 ///    pub const Argument: u64 = 42 + FIXED_VALUE;
 ///    /// Visibility of the type is optional

frame/support/src/lib.rs

@@ -17,8 +17,11 @@ frame-support = { version = "2.0.0-alpha.5", default-features = false, path = ".
 sp-inherents = { version = "2.0.0-alpha.5", default-features = false, path = "../../../primitives/inherents" }
 sp-runtime = { version = "2.0.0-alpha.5", default-features = false, path = "../../../primitives/runtime" }
 sp-core = { version = "2.0.0-alpha.5", default-features = false, path = "../../../primitives/core" }
-trybuild = "1.0.17"
+trybuild = "1.0.24"
 pretty_assertions = "0.6.1"
+# pin ed25519-dalek to 1.0.0-pre.3
+# otherwise cargo will resolve 1.0.0-pre.4 which is breaking.
+ed25519-dalek = "=1.0.0-pre.3"
 
 [features]
 default = ["std"]

frame/support/test/Cargo.toml

@@ -1380,7 +1380,7 @@ mod tests {
 		pub const MaximumBlockWeight: Weight = 1024;
 		pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
 		pub const MaximumBlockLength: u32 = 1024;
-		pub const Version: RuntimeVersion = RuntimeVersion {
+		pub Version: RuntimeVersion = RuntimeVersion {
 			spec_name: sp_version::create_runtime_str!("test"),
 			impl_name: sp_version::create_runtime_str!("system-test"),
 			authoring_version: 1,

frame/system/src/lib.rs

@@ -121,9 +121,28 @@ macro_rules! implement_per_thing {
 		///
 		#[doc = $title]
 		#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-		#[derive(Encode, Decode, Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, CompactAs)]
+		#[derive(Encode, Decode, Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug)]
 		pub struct $name($type);
 
+		/// Implementation makes any compact encoding of `PerThing::Inner` valid,
+		/// when decoding it will saturate up to `PerThing::ACCURACY`.
+		impl CompactAs for $name {
+			type As = $type;
+			fn encode_as(&self) -> &Self::As {
+				&self.0
+			}
+			fn decode_from(x: Self::As) -> Self {
+				// Saturates if `x` is more than `$max` internally. 
+				Self::from_parts(x)
+			}
+		}
+
+		impl From<codec::Compact<$name>> for $name {
+			fn from(x: codec::Compact<$name>) -> $name {
+				x.0
+			}
+		}
+
 		impl PerThing for $name {
 			type Inner = $type;
 			type Upper = $upper_type;
@@ -261,8 +280,8 @@ macro_rules! implement_per_thing {
 			}
 
 			/// See [`PerThing::one`].
-			pub fn one() -> Self {
-				<Self as PerThing>::one()
+			pub const fn one() -> Self {
+				Self::from_parts($max)
 			}
 
 			/// See [`PerThing::zero`].
@@ -714,6 +733,17 @@ macro_rules! implement_per_thing {
 				);
 			}
 
+			#[test]
+			fn compact_decoding_saturate_when_beyond_accuracy() {
+				use num_traits::Bounded;
+				use codec::Compact;
+
+				let p = Compact::<$name>::decode(&mut &Compact(<$type>::max_value()).encode()[..])
+					.unwrap();
+				assert_eq!((p.0).0, $max);
+				assert_eq!($name::from(p), $name::max_value());
+			}
+
 			#[test]
 			fn per_things_div_works() {
 				// normal

primitives/arithmetic/src/per_things.rs

@@ -192,6 +192,10 @@ pub fn elect<AccountId, Balance, C, R>(
 	voters.extend(initial_voters.into_iter().map(|(who, voter_stake, votes)| {
 		let mut edges: Vec<Edge<AccountId>> = Vec::with_capacity(votes.len());
 		for v in votes {
+			if edges.iter().any(|e| e.who == v) {
+				// duplicate edge.
+				continue;
+			}
 			if let Some(idx) = c_idx_cache.get(&v) {
 				// This candidate is valid + already cached.
 				candidates[*idx].approval_stake = candidates[*idx].approval_stake

primitives/phragmen/src/lib.rs

@@ -486,3 +486,63 @@ fn self_votes_should_be_kept() {
 		&Support { total: 20u128, voters: vec![(20u64, 20u128)] },
 	);
 }
+
+#[test]
+fn duplicate_target_is_ignored() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![
+		(10, 100, vec![1, 1, 2, 3]),
+		(20, 100, vec![2, 3]),
+		(30, 50, vec![1, 1, 2]),
+	];
+
+	let PhragmenResult { winners, assignments } = elect::<_, _, TestCurrencyToVote, Output>(
+		2,
+		2,
+		candidates,
+		voters,
+	).unwrap();
+	let (winners, _): (Vec<i32>, Vec<_>) = winners.into_iter().unzip();
+
+	assert_eq!(winners, vec![(2), (3)]);
+	assert_eq!(
+		assignments
+			.into_iter()
+			.map(|x| (x.0, x.1.into_iter().map(|(w, _)| w).collect::<Vec<_>>()))
+			.collect::<Vec<_>>(),
+		vec![
+			(10, vec![2, 3]),
+			(20, vec![2, 3]),
+			(30, vec![2]),
+		],
+	);
+}
+
+#[test]
+fn duplicate_target_is_ignored_when_winner() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![
+		(10, 100, vec![1, 1, 2, 3]),
+		(20, 100, vec![1, 2]),
+	];
+
+	let PhragmenResult { winners, assignments } = elect::<_, _, TestCurrencyToVote, Output>(
+		2,
+		2,
+		candidates,
+		voters,
+	).unwrap();
+	let (winners, _): (Vec<i32>, Vec<_>) = winners.into_iter().unzip();
+
+	assert_eq!(winners, vec![1, 2]);
+	assert_eq!(
+		assignments
+			.into_iter()
+			.map(|x| (x.0, x.1.into_iter().map(|(w, _)| w).collect::<Vec<_>>()))
+			.collect::<Vec<_>>(),
+		vec![
+			(10, vec![1, 2]),
+			(20, vec![1, 2]),
+		],
+	);
+}

primitives/phragmen/src/tests.rs

@@ -25,6 +25,7 @@ mod storage_proof;
 mod trie_stream;
 
 use sp_std::boxed::Box;
+use sp_std::borrow::Borrow;
 use sp_std::marker::PhantomData;
 use sp_std::vec::Vec;
 use hash_db::{Hasher, Prefix};
@@ -257,7 +258,7 @@ pub fn child_delta_trie_root<L: TrieConfiguration, I, A, B, DB, RD>(
 	root.as_mut().copy_from_slice(root_data.as_ref());
 
 	let mut db = KeySpacedDBMut::new(&mut *db, keyspace);
-	delta_trie_root::<L, _, _, _, _, _>(
+	delta_trie_root::<L, _, _, _, _>(
 		&mut db,
 		root,
 		delta,
@@ -464,7 +465,7 @@ mod trie_constants {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use codec::{Encode, Compact};
+	use codec::{Encode, Decode, Compact};
 	use sp_core::Blake2Hasher;
 	use hash_db::{HashDB, Hasher};
 	use trie_db::{DBValue, TrieMut, Trie, NodeCodec as NodeCodecT};
@@ -852,4 +853,34 @@ mod tests {
 			).is_err()
 		);
 	}
+
+	#[test]
+	fn generate_storage_root_with_proof_works_independently_from_the_delta_order() {
+		let proof = StorageProof::decode(&mut &include_bytes!("../test-res/proof")[..]).unwrap();
+		let storage_root = sp_core::H256::decode(
+			&mut &include_bytes!("../test-res/storage_root")[..],
+		).unwrap();
+		// Delta order that is "invalid" so that it would require a different proof.
+		let invalid_delta = Vec::<(Vec<u8>, Option<Vec<u8>>)>::decode(
+			&mut &include_bytes!("../test-res/invalid-delta-order")[..],
+		).unwrap();
+		// Delta order that is "valid"
+		let valid_delta = Vec::<(Vec<u8>, Option<Vec<u8>>)>::decode(
+			&mut &include_bytes!("../test-res/valid-delta-order")[..],
+		).unwrap();
+
+		let proof_db = proof.into_memory_db::<Blake2Hasher>();
+		let first_storage_root = delta_trie_root::<Layout, _, _, _, _>(
+			&mut proof_db.clone(),
+			storage_root,
+			valid_delta,
+		).unwrap();
+		let second_storage_root = delta_trie_root::<Layout, _, _, _, _>(
+			&mut proof_db.clone(),
+			storage_root,
+			invalid_delta,
+		).unwrap();
+
+		assert_eq!(first_storage_root, second_storage_root);
+	}
 }