Accept new Phragmén solutions if they are epsilon better + Better pre-inclusion checks. (#6173)

* part1: Accept inly epsilon better solutions

* Fix pre-dispatch check

* Fix build

* review grumbles

* Epsilon -> Threshold

substrate/primitives/phragmen/src/tests.rs

@@ -616,28 +616,153 @@ fn assignment_convert_works() {
 }
 
 #[test]
-fn score_comparison_is_lexicographical() {
+fn score_comparison_is_lexicographical_no_epsilon() {
+	let epsilon = Perbill::zero();
 	// only better in the fist parameter, worse in the other two ✅
 	assert_eq!(
-		is_score_better([10, 20, 30], [12, 10, 35]),
+		is_score_better([12, 10, 35], [10, 20, 30], epsilon),
 		true,
 	);
 
 	// worse in the first, better in the other two ❌
 	assert_eq!(
-		is_score_better([10, 20, 30], [9, 30, 10]),
+		is_score_better([9, 30, 10], [10, 20, 30], epsilon),
 		false,
 	);
 
 	// equal in the first, the second one dictates.
 	assert_eq!(
-		is_score_better([10, 20, 30], [10, 25, 40]),
+		is_score_better([10, 25, 40], [10, 20, 30], epsilon),
 		true,
 	);
 
 	// equal in the first two, the last one dictates.
 	assert_eq!(
-		is_score_better([10, 20, 30], [10, 20, 40]),
+		is_score_better([10, 20, 40], [10, 20, 30], epsilon),
+		false,
+	);
+}
+
+#[test]
+fn score_comparison_with_epsilon() {
+	let epsilon = Perbill::from_percent(1);
+
+	{
+		// no more than 1 percent (10) better in the first param.
+		assert_eq!(
+			is_score_better([1009, 5000, 100000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+
+		// now equal, still not better.
+		assert_eq!(
+			is_score_better([1010, 5000, 100000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+
+		// now it is.
+		assert_eq!(
+			is_score_better([1011, 5000, 100000], [1000, 5000, 100000], epsilon),
+			true,
+		);
+	}
+
+	{
+		// First score score is epsilon better, but first score is no longer `ge`. Then this is
+		// still not a good solution.
+		assert_eq!(
+			is_score_better([999, 6000, 100000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+	}
+
+	{
+		// first score is equal or better, but not epsilon. Then second one is the determinant.
+		assert_eq!(
+			is_score_better([1005, 5000, 100000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+
+		assert_eq!(
+			is_score_better([1005, 5050, 100000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+
+		assert_eq!(
+			is_score_better([1005, 5051, 100000], [1000, 5000, 100000], epsilon),
+			true,
+		);
+	}
+
+	{
+		// first score and second are equal or less than epsilon more, third is determinant.
+		assert_eq!(
+			is_score_better([1005, 5025, 100000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+
+		assert_eq!(
+			is_score_better([1005, 5025, 99_000], [1000, 5000, 100000], epsilon),
+			false,
+		);
+
+		assert_eq!(
+			is_score_better([1005, 5025, 98_999], [1000, 5000, 100000], epsilon),
+			true,
+		);
+	}
+}
+
+#[test]
+fn score_comparison_large_value() {
+	// some random value taken from eras in kusama.
+	let initial = [12488167277027543u128, 5559266368032409496, 118749283262079244270992278287436446];
+	// this claim is 0.04090% better in the third component. It should be accepted as better if
+	// epsilon is smaller than 5/10_0000
+	let claim = [12488167277027543u128, 5559266368032409496, 118700736389524721358337889258988054];
+
+	assert_eq!(
+		is_score_better(
+			claim.clone(),
+			initial.clone(),
+			Perbill::from_rational_approximation(1u32, 10_000),
+		),
+		true,
+	);
+
+	assert_eq!(
+		is_score_better(
+			claim.clone(),
+			initial.clone(),
+			Perbill::from_rational_approximation(2u32, 10_000),
+		),
+		true,
+	);
+
+	assert_eq!(
+		is_score_better(
+			claim.clone(),
+			initial.clone(),
+			Perbill::from_rational_approximation(3u32, 10_000),
+		),
+		true,
+	);
+
+	assert_eq!(
+		is_score_better(
+			claim.clone(),
+			initial.clone(),
+			Perbill::from_rational_approximation(4u32, 10_000),
+		),
+		true,
+	);
+
+	assert_eq!(
+		is_score_better(
+			claim.clone(),
+			initial.clone(),
+			Perbill::from_rational_approximation(5u32, 10_000),
+		),
 		false,
 	);
 }