Move sr-arithmetic to a new crate and add in a fuzzer (#3799)

* Split up sr_arithmetic.rs

* Add some basic fuzzing

* Add more tests

* Add printing to fuzzing

* Clean things up

* Remove arbitrary

* Remove comments

* More cleaning, fix small error that was causing a panic

* Add rational128

* Remove old random tests

* introduce panic

* fuzzing should panic properly

* Bit of cleanup

* Add a test uncovered via fuzzing that fails!

* Few small changes

* Move sr-arithmetic to its own crate

* Fix fuzzing

* Got rid of fuzzer Cargo.lock

* Added no_std

* re-export assert_eq_error_rate

* bump impl and spec version

* re add convert into

* Add an ignore to the test

* Enabled benchmarking

* Reindent

* Clean up biguint fuzzer

* Clean up biguint more

* shuffle sr-primitives/traits about

* Remove unused dependencies

* Apply clippy suggestions

* upgrade primitive-types versions

* Run tests against num-bigint

* Get rid of allocation in assert_biguints_eq

* Add an optimisation to multiply_by_rational

* rename parts_per_x -> per_things

* Change fuzzer cargo.toml

* Remove allocation from BigUint PartialEq impl

* Remove accidental indentation

* Renmove Lazy and Convert traits

* Copy assert_eq_error_rate macro back to sr-primitives

* Add documentation to fuzzers

* fix sr-primitives assert_eq_error_rate

* add cfg(test)

* Update core/sr-arithmetic/src/traits.rs

Co-Authored-By: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update core/sr-arithmetic/src/traits.rs

Co-Authored-By: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Update core/sr-arithmetic/fuzzer/src/biguint.rs

Co-Authored-By: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Allow rounding up in rational128

* Make changes to biguint.rs

* Update core/sr-arithmetic/src/traits.rs

Co-Authored-By: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

* Final touches

* Convert to num_bigint::BigUint to compare

* remove unused mut

* more small changes

* shuffle sr-primitives trait imports

* more code review

* move assert_eq_error_rate to lib.rs

* Update core/sr-arithmetic/fuzzer/src/biguint.rs

Co-Authored-By: Bastian Köcher <bkchr@users.noreply.github.com>

* Get rid of S

* Simplify rational128 honggfuzz link

* Insignificantly change rational128 fuzzing code

* Slightly tidy up some of the arithmetic logic

* Get rid of sr_arithmetic again(?) and fix sr-primitives/weights

* Apply updates to sr_arithmetic.rs to crate

substrate/core/sr-primitives/src/lib.rs

@@ -51,7 +51,6 @@ pub mod testing;
 pub mod curve;
 pub mod generic;
 pub mod offchain;
-pub mod sr_arithmetic;
 pub mod traits;
 pub mod transaction_validity;
 pub mod weights;
@@ -64,14 +63,14 @@ pub use primitives::{TypeId, crypto::{key_types, KeyTypeId, CryptoType}};
 pub use app_crypto::RuntimeAppPublic;
 
 /// Re-export top-level arithmetic stuff.
-pub use sr_arithmetic::{
+pub use arithmetic::{
 	Perquintill, Perbill, Permill, Percent,
 	Rational128, Fixed64
 };
 /// Re-export 128 bit helpers.
-pub use sr_arithmetic::helpers_128bit;
-/// Re-export big_uint stiff.
-pub use sr_arithmetic::biguint;
+pub use arithmetic::helpers_128bit;
+/// Re-export big_uint stuff.
+pub use arithmetic::biguint;
 
 /// An abstraction over justification for a block's validity under a consensus algorithm.
 ///

substrate/core/sr-primitives/src/traits.rs

@@ -24,20 +24,16 @@ use std::fmt::{Debug, Display};
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize, de::DeserializeOwned};
 use primitives::{self, Hasher, Blake2Hasher, TypeId};
-use crate::codec::{Codec, Encode, Decode, HasCompact};
+use crate::codec::{Codec, Encode, Decode};
 use crate::transaction_validity::{
 	ValidTransaction, TransactionValidity, TransactionValidityError, UnknownTransaction,
 };
 use crate::generic::{Digest, DigestItem};
 use crate::weights::DispatchInfo;
-pub use integer_sqrt::IntegerSquareRoot;
-pub use num_traits::{
+pub use arithmetic::traits::{
+	SimpleArithmetic, UniqueSaturatedInto, UniqueSaturatedFrom, Saturating, SaturatedConversion,
 	Zero, One, Bounded, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv,
-	CheckedShl, CheckedShr
-};
-use rstd::ops::{
-	Add, Sub, Mul, Div, Rem, AddAssign, SubAssign, MulAssign, DivAssign,
-	RemAssign, Shl, Shr
+	CheckedShl, CheckedShr, IntegerSquareRoot
 };
 use app_crypto::AppKey;
 use impl_trait_for_tuples::impl_for_tuples;
@@ -198,120 +194,6 @@ impl<A, B: From<A>> Convert<A, B> for ConvertInto {
 	fn convert(a: A) -> B { a.into() }
 }
 
-/// A meta trait for arithmetic.
-///
-/// Arithmetic types do all the usual stuff you'd expect numbers to do. They are guaranteed to
-/// be able to represent at least `u32` values without loss, hence the trait implies `From<u32>`
-/// and smaller ints. All other conversions are fallible.
-pub trait SimpleArithmetic:
-	Zero + One + IntegerSquareRoot +
-	From<u8> + From<u16> + From<u32> + TryInto<u8> + TryInto<u16> + TryInto<u32> +
-	TryFrom<u64> + TryInto<u64> + TryFrom<u128> + TryInto<u128> + TryFrom<usize> + TryInto<usize> +
-	UniqueSaturatedInto<u8> + UniqueSaturatedInto<u16> + UniqueSaturatedInto<u32> +
-	UniqueSaturatedFrom<u64> + UniqueSaturatedInto<u64> + UniqueSaturatedFrom<u128> + UniqueSaturatedInto<u128> +
-	Add<Self, Output = Self> + AddAssign<Self> +
-	Sub<Self, Output = Self> + SubAssign<Self> +
-	Mul<Self, Output = Self> + MulAssign<Self> +
-	Div<Self, Output = Self> + DivAssign<Self> +
-	Rem<Self, Output = Self> + RemAssign<Self> +
-	Shl<u32, Output = Self> + Shr<u32, Output = Self> +
-	CheckedShl + CheckedShr + CheckedAdd + CheckedSub + CheckedMul + CheckedDiv +
-	Saturating + PartialOrd<Self> + Ord + Bounded +
-	HasCompact + Sized
-{}
-impl<T:
-	Zero + One + IntegerSquareRoot +
-	From<u8> + From<u16> + From<u32> + TryInto<u8> + TryInto<u16> + TryInto<u32> +
-	TryFrom<u64> + TryInto<u64> + TryFrom<u128> + TryInto<u128> + TryFrom<usize> + TryInto<usize> +
-	UniqueSaturatedInto<u8> + UniqueSaturatedInto<u16> + UniqueSaturatedInto<u32> +
-	UniqueSaturatedFrom<u64> + UniqueSaturatedInto<u64> + UniqueSaturatedFrom<u128> +
-	UniqueSaturatedInto<u128> + UniqueSaturatedFrom<usize> + UniqueSaturatedInto<usize> +
-	Add<Self, Output = Self> + AddAssign<Self> +
-	Sub<Self, Output = Self> + SubAssign<Self> +
-	Mul<Self, Output = Self> + MulAssign<Self> +
-	Div<Self, Output = Self> + DivAssign<Self> +
-	Rem<Self, Output = Self> + RemAssign<Self> +
-	Shl<u32, Output = Self> + Shr<u32, Output = Self> +
-	CheckedShl + CheckedShr + CheckedAdd + CheckedSub + CheckedMul + CheckedDiv +
-	Saturating + PartialOrd<Self> + Ord + Bounded +
-	HasCompact + Sized
-> SimpleArithmetic for T {}
-
-/// Just like `From` except that if the source value is too big to fit into the destination type
-/// then it'll saturate the destination.
-pub trait UniqueSaturatedFrom<T: Sized>: Sized {
-	/// Convert from a value of `T` into an equivalent instance of `Self`.
-	fn unique_saturated_from(t: T) -> Self;
-}
-
-/// Just like `Into` except that if the source value is too big to fit into the destination type
-/// then it'll saturate the destination.
-pub trait UniqueSaturatedInto<T: Sized>: Sized {
-	/// Consume self to return an equivalent value of `T`.
-	fn unique_saturated_into(self) -> T;
-}
-
-impl<T: Sized, S: TryFrom<T> + Bounded + Sized> UniqueSaturatedFrom<T> for S {
-	fn unique_saturated_from(t: T) -> Self {
-		S::try_from(t).unwrap_or_else(|_| Bounded::max_value())
-	}
-}
-
-impl<T: Bounded + Sized, S: TryInto<T> + Sized> UniqueSaturatedInto<T> for S {
-	fn unique_saturated_into(self) -> T {
-		self.try_into().unwrap_or_else(|_| Bounded::max_value())
-	}
-}
-
-/// Simple trait to use checked mul and max value to give a saturated mul operation over
-/// supported types.
-pub trait Saturating {
-	/// Saturated addition - if the product can't fit in the type then just use max-value.
-	fn saturating_add(self, o: Self) -> Self;
-
-	/// Saturated subtraction - if the product can't fit in the type then just use max-value.
-	fn saturating_sub(self, o: Self) -> Self;
-
-	/// Saturated multiply - if the product can't fit in the type then just use max-value.
-	fn saturating_mul(self, o: Self) -> Self;
-}
-
-impl<T: CheckedMul + Bounded + num_traits::Saturating> Saturating for T {
-	fn saturating_add(self, o: Self) -> Self {
-		<Self as num_traits::Saturating>::saturating_add(self, o)
-	}
-	fn saturating_sub(self, o: Self) -> Self {
-		<Self as num_traits::Saturating>::saturating_sub(self, o)
-	}
-	fn saturating_mul(self, o: Self) -> Self {
-		self.checked_mul(&o).unwrap_or_else(Bounded::max_value)
-	}
-}
-
-/// Convenience type to work around the highly unergonomic syntax needed
-/// to invoke the functions of overloaded generic traits, in this case
-/// `SaturatedFrom` and `SaturatedInto`.
-pub trait SaturatedConversion {
-	/// Convert from a value of `T` into an equivalent instance of `Self`.
-	///
-	/// This just uses `UniqueSaturatedFrom` internally but with this
-	/// variant you can provide the destination type using turbofish syntax
-	/// in case Rust happens not to assume the correct type.
-	fn saturated_from<T>(t: T) -> Self where Self: UniqueSaturatedFrom<T> {
-		<Self as UniqueSaturatedFrom<T>>::unique_saturated_from(t)
-	}
-
-	/// Consume self to return an equivalent value of `T`.
-	///
-	/// This just uses `UniqueSaturatedInto` internally but with this
-	/// variant you can provide the destination type using turbofish syntax
-	/// in case Rust happens not to assume the correct type.
-	fn saturated_into<T>(self) -> T where Self: UniqueSaturatedInto<T> {
-		<Self as UniqueSaturatedInto<T>>::unique_saturated_into(self)
-	}
-}
-impl<T: Sized> SaturatedConversion for T {}
-
 /// Convenience type to work around the highly unergonomic syntax needed
 /// to invoke the functions of overloaded generic traits, in this case
 /// `TryFrom` and `TryInto`.

substrate/core/sr-primitives/src/weights.rs

@@ -24,7 +24,7 @@
 //! (something that does not  implement `Weighable`) is passed in.
 
 pub use crate::transaction_validity::TransactionPriority;
-use crate::traits::Bounded;
+use arithmetic::traits::Bounded;
 
 /// Numeric range of a transaction weight.
 pub type Weight = u32;