Fix domain for explorer (#51)

* Cargo.toml - add `derive_more`

* domain - BigNum - use `derive_more` and derive `Add`, `Div`, `Mul` & `Sub`

* domain - BigNum - impl `Sum` iterator

* domain - BigNum - derive `Ord`

* domain - BigNum - derive `PartialEq`, `Eq`, `PartialOrd` & `Ord`

* domain - BigNum - fix `impl Sum<BigNum>` to a `Sum<&'a BigNum>`

* domain - BigNum - Impl `Mul`, `Div` `Sum<&BigNum>` & `Sum<BigNum>` + other methods from BigUint

Author: elpiel

Cargo.lock

@@ -20,6 +20,7 @@ num-bigint = { version = "0.2", features = ["serde"] }
 chrono = { version = "0.4", features = ["serde"] }
 time = "0.1.42"
 hex = "0.3.2"
+num = "0.2.0"
 # Fixtures
 fake = { version = "^1.3", features = ["chrono"], optional = true }
 rand = { version = "^0.6", optional = true }

domain/Cargo.toml

@@ -1,11 +1,13 @@
 use std::convert::TryFrom;
 use std::error::Error;
+use std::iter::Sum;
 use std::str::FromStr;
 
 use num_bigint::BigUint;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::ops::{Div, Mul};
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct BigNum(
     #[serde(
         deserialize_with = "biguint_from_str",
@@ -18,6 +20,58 @@ impl BigNum {
     pub fn new(num: BigUint) -> Result<Self, super::DomainError> {
         Ok(Self(num))
     }
+
+    pub fn div_floor(&self, other: &Self) -> Self {
+        use num::integer::Integer;
+
+        Self(self.0.div_floor(&other.0))
+    }
+
+    pub fn to_f64(&self) -> Option<f64> {
+        use num::traits::cast::ToPrimitive;
+
+        self.0.to_f64()
+    }
+
+    pub fn to_u64(&self) -> Option<u64> {
+        use num::traits::cast::ToPrimitive;
+
+        self.0.to_u64()
+    }
+}
+
+impl Div<&BigNum> for &BigNum {
+    type Output = BigNum;
+
+    fn div(self, rhs: &BigNum) -> Self::Output {
+        let big_uint = &self.0 / &rhs.0;
+        BigNum(big_uint.to_owned())
+    }
+}
+
+impl Mul<&BigNum> for &BigNum {
+    type Output = BigNum;
+
+    fn mul(self, rhs: &BigNum) -> Self::Output {
+        let big_uint = &self.0 * &rhs.0;
+        BigNum(big_uint.to_owned())
+    }
+}
+
+impl<'a> Sum<&'a BigNum> for BigNum {
+    fn sum<I: Iterator<Item = &'a BigNum>>(iter: I) -> Self {
+        let sum_uint = iter.map(|big_num| &big_num.0).sum();
+
+        Self(sum_uint)
+    }
+}
+
+impl Sum<BigNum> for BigNum {
+    fn sum<I: Iterator<Item = BigNum>>(iter: I) -> Self {
+        let sum_uint = iter.map(|big_num| big_num.0).sum();
+
+        Self(sum_uint)
+    }
 }
 
 impl TryFrom<&str> for BigNum {
@@ -37,11 +91,9 @@ impl ToString for BigNum {
     }
 }
 
-impl TryFrom<u32> for BigNum {
-    type Error = super::DomainError;
-
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
-        BigNum::new(BigUint::from(value))
+impl From<u64> for BigNum {
+    fn from(value: u64) -> Self {
+        BigNum(BigUint::from(value))
     }
 }
 

domain/src/bignum.rs

@@ -1,5 +1,3 @@
-use std::convert::TryFrom;
-
 use chrono::{DateTime, Utc};
 use fake::faker::*;
 
@@ -33,8 +31,7 @@ pub fn get_channel(
     spec: Option<ChannelSpec>,
 ) -> Channel {
     let channel_id = get_channel_id(id);
-    let deposit_amount = BigNum::try_from(<Faker as Number>::between(100_u32, 5000_u32))
-        .expect("BigNum error when creating from random number");
+    let deposit_amount = BigNum::from(<Faker as Number>::between(100, 5000));
     let valid_until: DateTime<Utc> =
         valid_until.unwrap_or(test_util::time::datetime_between(&Utc::now(), None));
     let creator = <Faker as Name>::name();
@@ -84,12 +81,9 @@ pub fn get_channel_spec(prefix: &str, validators_option: ValidatorsOption) -> Ch
     let title_string = Some(<Faker as Lorem>::sentence(3, 4));
 
     let title = take_one(&[&title_string, &None]).to_owned();
-    let max_per_impression = BigNum::try_from(<Faker as Number>::between(250_u32, 500_u32))
-        .expect("BigNum error when creating from random number");
-    let min_per_impression = BigNum::try_from(<Faker as Number>::between(1_u32, 250_u32))
-        .expect("BigNum error when creating from random number");
-    let nonce = BigNum::try_from(<Faker as Number>::between(100_000_000_u32, 999_999_999_u32))
-        .expect("BigNum error when creating from random number");
+    let max_per_impression = BigNum::from(<Faker as Number>::between(250, 500));
+    let min_per_impression = BigNum::from(<Faker as Number>::between(1, 250));
+    let nonce = BigNum::from(<Faker as Number>::between(100_000_000, 999_999_999));
     let min_targeting_score =
         take_one(&[&None, &Some(<Faker as Number>::between(1, 500))]).to_owned();
 

domain/src/channel_fixtures.rs

@@ -14,6 +14,7 @@ pub struct Score(#[serde(deserialize_with = "score_deserialize")] u8);
 
 impl Score {
     /// score should be between 0 and 100
+    #[allow(dead_code)]
     fn new(score: u8) -> Result<Self, DomainError> {
         if score > 100 {
             return Err(DomainError::InvalidArgument(

domain/src/targeting_tag.rs

@@ -12,17 +12,14 @@ pub struct ValidatorDesc {
 
 #[cfg(any(test, feature = "fixtures"))]
 pub(crate) mod fixtures {
-    use std::convert::TryFrom;
-
     use fake::faker::*;
 
     use crate::BigNum;
 
     use super::ValidatorDesc;
 
     pub fn get_validator(validator_id: &str) -> ValidatorDesc {
-        let fee = BigNum::try_from(<Faker as Number>::between(1_u32, 13_u32))
-            .expect("BigNum error when creating from random number");
+        let fee = BigNum::from(<Faker as Number>::between(1, 13));
         let url = format!("http://{}-validator-url.com/validator", validator_id);
 
         ValidatorDesc {