remove that unwanted Distribution struct

Author: elpiel

validator_worker/src/core/fees.rs

@@ -5,24 +5,58 @@ pub fn get_balances_after_fees_tree(
     balances: &BalancesMap,
     channel: &Channel,
 ) -> Result<BalancesMap, DomainError> {
-    let distribution = Distribution::new(balances, &channel)?;
+    let deposit = 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 {
+        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());
 
     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 == total_distributed {
+        &to_distribute - &total_distributed
+    } else {
+        BigNum::from(0)
+    };
+
+    if rounding_error < BigNum::from(0) {
+        return Err(DomainError::RuleViolation(
+            "The Rounding error should never be negative".into(),
+        ));
+    }
 
     let balances_after_fees = distribute_fee(
         balances_after_fees,
         rounding_error,
-        distribution.fee_ratio,
+        fee_ratio,
         channel.spec.validators.into_iter(),
     );
 
@@ -56,77 +90,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::*;