use float10 new api

src/consensus/constants.rs

@@ -20,7 +20,6 @@ use lazy_static::lazy_static;
 
 use crate::{consensus::Float10, util::time::Timestamp};
 
-
 lazy_static! {
     /// Genesis hash for the mainnet chain
     pub static ref MAINNET_GENESIS_HASH_BYTES: blake3::Hash = blake3::hash(b"darkfi_mainnet");
@@ -28,10 +27,10 @@ lazy_static! {
     // NOTE: On initial network bootstrap, genesis timestamp should be equal to boostrap timestamp.
     // On network restart only change bootstrap timestamp to schedule when nodes become active.
     /// Genesis timestamp for the mainnet chain
-    pub static ref MAINNET_GENESIS_TIMESTAMP: Timestamp = Timestamp(1773025405);
+    pub static ref MAINNET_GENESIS_TIMESTAMP: Timestamp = Timestamp(1650887115);
 
     /// Bootstrap timestamp for the mainnet chain
-    pub static ref MAINNET_BOOTSTRAP_TIMESTAMP: Timestamp = Timestamp(1773025405);
+    pub static ref MAINNET_BOOTSTRAP_TIMESTAMP: Timestamp = Timestamp(1650887115);
 
     /// Total sum of initial staking coins for the mainnet chain
     pub static ref MAINNET_INITIAL_DISTRIBUTION: u64 = 1000;
@@ -40,43 +39,39 @@ lazy_static! {
     pub static ref TESTNET_GENESIS_HASH_BYTES: blake3::Hash = blake3::hash(b"darkfi_testnet");
 
     /// Genesis timestamp for the testnet chain
-    pub static ref TESTNET_GENESIS_TIMESTAMP: Timestamp = Timestamp(1673281500);
+
+    pub static ref TESTNET_GENESIS_TIMESTAMP: Timestamp = Timestamp(1672785000);
 
     /// Bootstrap timestamp for the testnet chain
-    pub static ref TESTNET_BOOTSTRAP_TIMESTAMP: Timestamp = Timestamp(1673281500);
+    pub static ref TESTNET_BOOTSTRAP_TIMESTAMP: Timestamp = Timestamp(1672785000);
+
 
     /// Total sum of initial staking coins for the testnet chain
     pub static ref TESTNET_INITIAL_DISTRIBUTION: u64 = 1000;
 
     // Commonly used Float10
 
-    pub static ref FLOAT10_NEG_ONE: Float10 = Float10::from_str_native("-1").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_NEG_TWO: Float10 = Float10::from_str_native("-2").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_ZERO: Float10 = Float10::from_str_native("0").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_ONE: Float10 = Float10::from_str_native("1").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_TWO: Float10 = Float10::from_str_native("2").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_THREE: Float10 = Float10::from_str_native("3").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_FIVE: Float10 = Float10::from_str_native("5").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_NINE: Float10 = Float10::from_str_native("9").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref FLOAT10_TEN: Float10 = Float10::from_str_native("10").unwrap().with_precision(RADIX_BITS).value();
-
+    pub static ref FLOAT10_NEG_TWO: Float10 = Float10::try_from("-2").unwrap();
+    pub static ref FLOAT10_NEG_ONE: Float10 = Float10::try_from("-1").unwrap();
+    pub static ref FLOAT10_ZERO: Float10 = Float10::try_from("0").unwrap();
+    pub static ref FLOAT10_ONE: Float10 = Float10::try_from("1").unwrap();
+    pub static ref FLOAT10_TWO: Float10 = Float10::try_from("2").unwrap();
+    pub static ref FLOAT10_THREE: Float10 = Float10::try_from("3").unwrap();
+    pub static ref FLOAT10_FIVE: Float10 = Float10::try_from("5").unwrap();
+    pub static ref FLOAT10_NINE: Float10 = Float10::try_from("9").unwrap();
+    pub static ref FLOAT10_TEN: Float10 = Float10::try_from("10").unwrap();
 
     // Consensus parameters
 
-    pub static ref TI: Float10 = FLOAT10_ONE.clone();
-    pub static ref TD: Float10 = FLOAT10_ONE.clone();
-    // pid discrete parameters
-
-    pub static ref KP: Float10 = Float10::from_str_native("0.18").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref KI: Float10 = Float10::from_str_native("0.02").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref KD: Float10 = Float10::from_str_native("-0.1").unwrap().with_precision(RADIX_BITS).value();
 
-    pub static ref PID_OUT_STEP: Float10  = Float10::from_str_native("0.1").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref MAX_DER: Float10 = Float10::from_str_native("0.1").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref MIN_DER: Float10 = Float10::from_str_native("-0.1").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref MAX_F: Float10 = Float10::from_str_native("0.99").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref MIN_F: Float10 = Float10::from_str_native("0.01").unwrap().with_precision(RADIX_BITS).value();
-    pub static ref DEG_RATE: Float10 = Float10::from_str_native("0.9").unwrap().with_precision(RADIX_BITS).value();
+    pub static ref KP: Float10 = Float10::try_from("0.18").unwrap();
+    pub static ref KI: Float10 = Float10::try_from("0.02").unwrap();
+    pub static ref KD: Float10 = Float10::try_from("-0.1").unwrap();
+    pub static ref PID_OUT_STEP: Float10  = Float10::try_from("0.1").unwrap();
+    pub static ref MAX_DER: Float10 = Float10::try_from("0.1").unwrap();
+    pub static ref MIN_DER: Float10 = Float10::try_from("-0.1").unwrap();
+    pub static ref MAX_F: Float10 = Float10::try_from("0.99").unwrap();
+    pub static ref MIN_F: Float10 = Float10::try_from("0.05").unwrap();
 
 }
 

src/consensus/state.rs

@@ -248,8 +248,8 @@ impl ConsensusState {
         let f = self.win_inv_prob_with_full_stake();
         let total_stake = self.total_stake();
 
-        let total_sigma =
-            Float10::try_from(total_stake).unwrap().with_precision(constants::RADIX_BITS).value();
+        let total_sigma = Float10::try_from(total_stake).unwrap();
+
         Self::calc_sigmas(f, total_sigma)
     }
 
@@ -262,10 +262,8 @@ impl ConsensusState {
         let two = constants::FLOAT10_TWO.clone();
 
 
-        let field_p = Float10::from_str_native(constants::P)
-            .unwrap()
-            .with_precision(constants::RADIX_BITS)
-            .value();
+        let field_p = Float10::try_from(constants::P).unwrap();
+
 
 
         let x = one - f;
@@ -416,7 +414,7 @@ impl ConsensusState {
 
     fn f_err(&mut self) -> Float10 {
         let len = self.leaders_history.len();
-        let feedback = Float10::try_from(self.leaders_history[len-1] as i64).unwrap().with_precision(constants::RADIX_BITS).value();
+        let feedback = Float10::try_from(self.leaders_history[len-1] as i64).unwrap();
         let target = constants::FLOAT10_ONE.clone();
         target - feedback
     }
@@ -964,14 +962,14 @@ mod tests {
 
     #[test]
     fn calc_sigmas_test() {
-        let giga_epsilon = Float10::from_str_native("10000000000000000000000000000000000000000000000000000000000").unwrap();
+        let giga_epsilon = Float10::try_from("10000000000000000000000000000000000000000000000000000000000").unwrap();
         let giga_epsilon_base = fbig2base(giga_epsilon);
-        let f = Float10::from_str_native("0.5").unwrap();
-        let total_stake = Float10::from_str_native("1000").unwrap();
+        let f = Float10::try_from("0.5").unwrap();
+        let total_stake = Float10::try_from("1000").unwrap();
         let (sigma1, sigma2) = ConsensusState::calc_sigmas(f, total_stake);
-        let sigma1_rhs = Float10::from_str_native("20065240046497827749443820209808913616958821867408735207193448041041362944").unwrap();
+        let sigma1_rhs = Float10::try_from("20065240046497827749443820209808913616958821867408735207193448041041362944").unwrap();
         let sigma1_rhs_base = fbig2base(sigma1_rhs);
-        let sigma2_rhs = Float10::from_str_native("6954082282744237239883318512759812991231744634473746668074299461468160").unwrap();
+        let sigma2_rhs = Float10::try_from("6954082282744237239883318512759812991231744634473746668074299461468160").unwrap();
         let sigma2_rhs_base = fbig2base(sigma2_rhs);
         let sigma1_delta = if sigma1_rhs_base>sigma1 {
             sigma1_rhs_base - sigma1