min multiplier definition and testing

Author: gabriele-0201

sugondat/chain/runtimes/sugondat-kusama/src/lib.rs

@@ -65,6 +65,7 @@ use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
 use xcm::latest::prelude::BodyId;
 
 pub use pallet_sugondat_blobs;
+pub use pallet_sugondat_length_fee_adjustment;
 
 /// A hash of some data used by the chain.
 pub type Hash = sp_core::H256;
@@ -287,8 +288,10 @@ parameter_types! {
     //  v = p / k * (1 - s*) = 0.3 / (300 * (1 - 0.16))
     //  at most 30% (=p) fees variation in one hour, 300 blocks (=k)
     pub AdjustmentVariableBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 840);
-    // TODO: decide the value of MinimumMultiplierBlockSize, https://github.com/thrumdev/blobs/issues/154
-    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 10u128);
+    // Using an adjustment variable block size of 1/840
+    // and a minimum multiplier block size of 1/200,
+    // it would require 5298 full blocks to grow back to one.
+    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 200u128);
     pub MaximumMultiplierBlockSize: Multiplier = Bounded::max_value();
 }
 

sugondat/chain/runtimes/sugondat-kusama/tests/fee_adjustments.rs

@@ -142,14 +142,6 @@ impl MultiplierType {
         }
     }
 
-    // k = 1 / (v * s*)
-    fn k_bound(&self) -> u64 {
-        (Multiplier::saturating_from_integer(1)
-            / (self.target_percentage() * self.adjustment_variable()))
-        .to_float()
-        .ceil() as u64
-    }
-
     fn run_with<F>(&self, w: Weight, assertions: F)
     where
         F: Fn() -> (),
@@ -248,6 +240,10 @@ fn multiplier_cannot_go_below_limit() {
 
 #[test]
 fn time_to_reach_zero() {
+    // TODO: 1440 needs to ne used insted of 7200
+    // when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    //
     // blocks per 24h in cumulus-node: 7200 (k)
     // s* = 0.1875 (TargetBlockFullness) or 0.16 (TargetBlockSize)
     // The bound from the research in an empty chain is:
@@ -268,7 +264,11 @@ fn time_to_reach_zero() {
             // start from 1, the default.
             let mut fm = Multiplier::one();
             let mut iterations: u64 = 0;
-            let limit = mul_type.k_bound();
+            let limit = (Multiplier::saturating_from_integer(1)
+                / (mul_type.target_percentage() * mul_type.adjustment_variable()))
+            .to_float()
+            .ceil() as u64;
+
             loop {
                 let next = mul_type.runtime_multiplier_update(fm);
                 fm = next;
@@ -285,6 +285,54 @@ fn time_to_reach_zero() {
     test(MultiplierType::Length);
 }
 
+#[test]
+fn time_to_reach_one() {
+    // TODO: 1440 needs to ne used insted of 7200
+    // when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    //
+    // blocks per 24h in cumulus-node: 7200 (k)
+    // s* = 0.1875 (TargetBlockFullness) or 0.16 (TargetBlockSize)
+    // The bound from the research in an full chain is:
+    // v <~ (p / k(1 - s*))
+    // p > v * k * (1 - s*)
+    // to get p == 1 we'd need (going from zero to target)
+    // 1 > v * k * (1 - s*)
+    // k < 1 / (v * (1 - s*))
+
+    // if s* = 0.1875
+    //  then k > 17_778 ~ 2.47 days
+    // else s* = 0.16
+    //  then k > 1000 ~ 3.3 hours
+
+    let test = |mul_type: MultiplierType| {
+        mul_type.run_with(mul_type.max(), || {
+            // start from min_multiplier, the default.
+            let mut fm = mul_type.min_multiplier();
+            let mut iterations: u64 = 0;
+
+            let limit = (Multiplier::saturating_from_integer(1)
+                / ((Multiplier::saturating_from_integer(1) - mul_type.target_percentage())
+                    * mul_type.adjustment_variable()))
+            .to_float()
+            .ceil() as u64;
+
+            loop {
+                let next = mul_type.runtime_multiplier_update(fm);
+                fm = next;
+                if fm >= Multiplier::one() {
+                    break;
+                }
+                iterations += 1;
+            }
+            assert!(iterations > limit);
+        })
+    };
+
+    test(MultiplierType::Fee);
+    test(MultiplierType::Length);
+}
+
 #[test]
 fn min_change_per_day() {
     let test = |mul_type: MultiplierType| {
@@ -296,6 +344,10 @@ fn min_change_per_day() {
                 let next = mul_type.runtime_multiplier_update(fm);
                 fm = next;
             }
+            // TODO: 1440 needs to ne used insted of 7200
+            // when updating to asynchronous backing
+            // https://github.com/thrumdev/blobs/issues/166
+            //
             // 7200 blocks per day with one 12 seconds blocks
             // v * k * (1 - s)
             let expected = mul_type.adjustment_variable()

sugondat/chain/runtimes/test/src/lib.rs

@@ -355,8 +355,10 @@ parameter_types! {
     //  v = p / k * (1 - s*) = 0.3 / (300 * (1 - 0.16))
     //  at most 30% (=p) fees variation in one hour, 300 blocks (=k)
     pub AdjustmentVariableBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 840);
-    // TODO: decide the value of MinimumMultiplierBlockSize, https://github.com/thrumdev/blobs/issues/154
-    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 1000u128);
+    // Using an adjustment variable block size of 1/840
+    // and a minimum multiplier block size of 1/200,
+    // it would require 5298 full blocks to grow back to one.
+    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 200u128);
     pub MaximumMultiplierBlockSize: Multiplier = Bounded::max_value();
 }
 

sugondat/chain/runtimes/test/tests/fee_adjustments.rs

@@ -138,14 +138,6 @@ impl MultiplierType {
         }
     }
 
-    // k = 1 / (v * s*)
-    fn k_bound(&self) -> u64 {
-        (Multiplier::saturating_from_integer(1)
-            / (self.target_percentage() * self.adjustment_variable()))
-        .to_float()
-        .ceil() as u64
-    }
-
     fn run_with<F>(&self, w: Weight, assertions: F)
     where
         F: Fn() -> (),
@@ -244,6 +236,10 @@ fn multiplier_cannot_go_below_limit() {
 
 #[test]
 fn time_to_reach_zero() {
+    // TODO: 1440 needs to ne used insted of 7200
+    // when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    //
     // blocks per 24h in cumulus-node: 7200 (k)
     // s* = 0.1875 (TargetBlockFullness) or 0.16 (TargetBlockSize)
     // The bound from the research in an empty chain is:
@@ -264,7 +260,11 @@ fn time_to_reach_zero() {
             // start from 1, the default.
             let mut fm = Multiplier::one();
             let mut iterations: u64 = 0;
-            let limit = mul_type.k_bound();
+            let limit = (Multiplier::saturating_from_integer(1)
+                / (mul_type.target_percentage() * mul_type.adjustment_variable()))
+            .to_float()
+            .ceil() as u64;
+
             loop {
                 let next = mul_type.runtime_multiplier_update(fm);
                 fm = next;
@@ -281,6 +281,54 @@ fn time_to_reach_zero() {
     test(MultiplierType::Length);
 }
 
+#[test]
+fn time_to_reach_one() {
+    // TODO: 1440 needs to ne used insted of 7200
+    // when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    //
+    // blocks per 24h in cumulus-node: 7200 (k)
+    // s* = 0.1875 (TargetBlockFullness) or 0.16 (TargetBlockSize)
+    // The bound from the research in an full chain is:
+    // v <~ (p / k(1 - s*))
+    // p > v * k * (1 - s*)
+    // to get p == 1 we'd need (going from zero to target)
+    // 1 > v * k * (1 - s*)
+    // k < 1 / (v * (1 - s*))
+
+    // if s* = 0.1875
+    //  then k > 17_778 ~ 2.47 days
+    // else s* = 0.16
+    //  then k > 1000 ~ 3.3 hours
+
+    let test = |mul_type: MultiplierType| {
+        mul_type.run_with(mul_type.max(), || {
+            // start from min_multiplier, the default.
+            let mut fm = mul_type.min_multiplier();
+            let mut iterations: u64 = 0;
+
+            let limit = (Multiplier::saturating_from_integer(1)
+                / ((Multiplier::saturating_from_integer(1) - mul_type.target_percentage())
+                    * mul_type.adjustment_variable()))
+            .to_float()
+            .ceil() as u64;
+
+            loop {
+                let next = mul_type.runtime_multiplier_update(fm);
+                fm = next;
+                if fm >= Multiplier::one() {
+                    break;
+                }
+                iterations += 1;
+            }
+            assert!(iterations > limit);
+        })
+    };
+
+    test(MultiplierType::Fee);
+    test(MultiplierType::Length);
+}
+
 #[test]
 fn min_change_per_day() {
     let test = |mul_type: MultiplierType| {
@@ -292,6 +340,10 @@ fn min_change_per_day() {
                 let next = mul_type.runtime_multiplier_update(fm);
                 fm = next;
             }
+            // TODO: 1440 needs to ne used insted of 7200
+            // when updating to asynchronous backing
+            // https://github.com/thrumdev/blobs/issues/166
+            //
             // 7200 blocks per day with one 12 seconds blocks
             // v * k * (1 - s)
             let expected = mul_type.adjustment_variable()