Merge pull request #138 from AdExNetwork/issue-113-remove-Distribution-struct

Issue #113 remove distribution struct

Author: samparsky

validator_worker/src/core/fees.rs

@@ -1,28 +1,61 @@
 use num::rational::Ratio;
+use num_traits::CheckedSub;
 use primitives::{BalancesMap, BigNum, Channel, DomainError, ValidatorDesc};
 
 pub fn get_balances_after_fees_tree(
     balances: &BalancesMap,
     channel: &Channel,
 ) -> Result<BalancesMap, DomainError> {
-    let distribution = Distribution::new(balances, &channel)?;
+    let deposit_amount = channel.deposit_amount.clone();
+
+    let total_distributed = balances.iter().map(|(_, balance)| balance).sum::<BigNum>();
+
+    let validators_iter = channel.spec.validators.into_iter();
+    let total_validators_fee = validators_iter
+        .map(|validator| &validator.fee)
+        .sum::<BigNum>();
+
+    if total_validators_fee > deposit_amount {
+        return Err(DomainError::RuleViolation(
+            "total fees <= deposit: fee constraint violated".into(),
+        ));
+    }
+
+    if total_distributed > deposit_amount {
+        return Err(DomainError::RuleViolation(
+            "distributed <= deposit: OUTPACE rule #4".into(),
+        ));
+    }
+
+    let deposit_to_distribute = &deposit_amount - &total_validators_fee;
+
+    let ratio = Ratio::new(deposit_to_distribute.clone(), deposit_amount.clone());
+    let fee_ratio = Ratio::new(total_distributed.clone(), deposit_amount.clone());
 
     let mut balances_after_fees = BalancesMap::default();
     let mut total = BigNum::from(0);
 
     for (key, value) in balances.iter() {
-        let adjusted_balance = value * &distribution.ratio;
+        let adjusted_balance = value * &ratio;
 
         total += &adjusted_balance;
         balances_after_fees.insert(key.clone(), adjusted_balance);
     }
 
-    let rounding_error = distribution.rounding_error(&total)?;
+    let rounding_error = if deposit_amount == total_distributed {
+        deposit_to_distribute
+            .checked_sub(&total)
+            .ok_or(DomainError::RuleViolation(
+                "rounding_err should never be negative".to_owned(),
+            ))?
+    } else {
+        BigNum::from(0)
+    };
 
     let balances_after_fees = distribute_fee(
         balances_after_fees,
         rounding_error,
-        distribution.fee_ratio,
+        fee_ratio,
         channel.spec.validators.into_iter(),
     );
 
@@ -56,77 +89,6 @@ fn distribute_fee<'a>(
     balances
 }
 
-#[derive(Debug)]
-struct Distribution {
-    pub deposit: BigNum,
-    /// Total Distributed is the sum of all balances in the BalancesMap
-    pub total_distributed: BigNum,
-    /// The Sum of all validators fee
-    pub validators_fee: BigNum,
-    /// Deposit - Validators fee
-    pub to_distribute: BigNum,
-    /// The ratio that is (Deposit - TotalValidatorFee) / Deposit
-    pub ratio: Ratio<BigNum>,
-    /// Total Distributed / Deposit
-    pub fee_ratio: Ratio<BigNum>,
-    _secret: (),
-}
-
-impl Distribution {
-    pub fn new(for_balances: &BalancesMap, on_channel: &Channel) -> Result<Self, DomainError> {
-        let deposit = on_channel.deposit_amount.clone();
-
-        let total_distributed: BigNum = for_balances.iter().map(|(_, balance)| balance).sum();
-
-        let validators_iter = on_channel.spec.validators.into_iter();
-        let total_validators_fee: BigNum = validators_iter.map(|validator| &validator.fee).sum();
-
-        if total_validators_fee > deposit {
-            return Err(DomainError::RuleViolation(
-                "total fees <= deposit: fee constraint violated".into(),
-            ));
-        }
-
-        if total_distributed > deposit {
-            return Err(DomainError::RuleViolation(
-                "distributed <= deposit: OUTPACE rule #4".into(),
-            ));
-        }
-
-        let to_distribute = &deposit - &total_validators_fee;
-
-        let ratio = Ratio::new(to_distribute.clone(), deposit.clone());
-        let fee_ratio = Ratio::new(total_distributed.clone(), deposit.clone());
-
-        Ok(Self {
-            deposit,
-            total_distributed,
-            validators_fee: total_validators_fee,
-            to_distribute,
-            ratio,
-            fee_ratio,
-            _secret: (),
-        })
-    }
-
-    /// Returns the rounding error and also checks for rule violation if it is < 0
-    pub fn rounding_error(&self, total_distributed: &BigNum) -> Result<BigNum, DomainError> {
-        let rounding_error = if self.deposit == self.total_distributed {
-            &self.to_distribute - total_distributed
-        } else {
-            BigNum::from(0)
-        };
-
-        if rounding_error < BigNum::from(0) {
-            Err(DomainError::RuleViolation(
-                "The Rounding error should never be negative".into(),
-            ))
-        } else {
-            Ok(rounding_error)
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;