fees: add max skipped blocks constant to pallet

sugondat/chain/pallets/length-fee-adjustment/Cargo.toml

@@ -29,6 +29,7 @@ polkadot-primitives = { workspace = true }
 [dev-dependencies]
 sp-io = { workspace = true }
 sp-core = { workspace = true }
+sugondat-primitives = { workspace = true, features = ["std"] }
 
 [features]
 default = [ "std" ]
@@ -53,4 +54,4 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"dep:sp-io"
 ]
-try-runtime = [ "frame-support/try-runtime" ]
+try-runtime = [ "frame-support/try-runtime" ]

sugondat/chain/pallets/length-fee-adjustment/src/lib.rs

@@ -99,13 +99,18 @@ pub mod pallet {
         ///
         /// Here, m represents the number of terms needed to be below the error.
         /// The smallest value of m that satisfies the inequality should be used as the value for this parameter.
-        ///
-        /// The maximum number of skipped blocks is used to ensure that only the right amount of terms is used,
-        /// and no terms are wasted. If n is exceeded, the approximation could diverge significantly from the actual value of e^x.
-        /// This means that producing a block at most every n skipped blocks should be enforced to avoid falling into this error.
         #[pallet::constant]
         type SkippedBlocksNumberTerms: Get<u32>;
 
+        /// The maximum number of skipped blocks is used to ensure that only the right amount of terms is used
+        /// and no terms are wasted. If n is exceeded, the approximation could diverge significantly from the actual value of e^x.
+        /// If the number of skipped blocks exceeds this value, it will be bounded to this value.
+        /// However, this limitation comes at the cost of losing the real fee adjustment update.
+        /// Therefore, producing a block at most every n skipped blocks should be enforced to avoid falling into this circumstance.
+        #[pallet::constant]
+        type MaximumSkippedBlocks: Get<u32>;
+
+        /// A source to provide the relay-parent number of the previous block.
         type LastRelayBlockNumberProvider: LastRelayBlockNumberProvider;
     }
 
@@ -243,10 +248,11 @@ pub mod pallet {
             // However, saturating it to zero will prevent the multiplier from changing
             let relay_parent_distance = relay_block_number.saturating_sub(prev_relay_block_number);
 
-            // TODO: update with `n_skipped_blocks = relay_parent_distance.saturating_sub(1)`
+            // TODO: update with `relay_parent_distance.saturating_sub(1)`
             // when updating to asynchronous backing
             // https://github.com/thrumdev/blobs/issues/166
-            let n_skipped_blocks = relay_parent_distance.saturating_sub(2) / 2;
+            let n_skipped_blocks =
+                (relay_parent_distance.saturating_sub(2) / 2).min(T::MaximumSkippedBlocks::get());
 
             let n_skipped_blocks = Multiplier::saturating_from_integer(n_skipped_blocks);
             let target_block_size = Multiplier::from(TargetBlockSize::<T>::get());

sugondat/chain/pallets/length-fee-adjustment/src/mock.rs

@@ -87,6 +87,7 @@ parameter_types! {
     // https://github.com/thrumdev/blobs/issues/166
     // Accepted error is less than 10^(-2)
     pub SkippedBlocksNumberTerms: u32 = 3;
+    pub MaximumSkippedBlocks: u32 = sugondat_primitives::MAX_SKIPPED_BLOCKS;
 
     pub static WeightToFee: u64 = 1;
     pub static OperationalFeeMultiplier: u8 = 5;
@@ -130,5 +131,6 @@ impl pallet_sugondat_length_fee_adjustment::Config for Test {
     type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
     type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
     type SkippedBlocksNumberTerms = SkippedBlocksNumberTerms;
+    type MaximumSkippedBlocks = MaximumSkippedBlocks;
     type LastRelayBlockNumberProvider = MockLastRelayBlockNumberProvider;
 }

sugondat/chain/pallets/length-fee-adjustment/src/tests.rs

@@ -89,12 +89,9 @@ fn test_no_update_when_prev_is_zero() {
 
 #[test]
 fn test_skipped_block_multiplier_update() {
-    // TODO: change max_skipped_blocks to 7200
-    // when updating to asynchronous backing
-    // https://github.com/thrumdev/blobs/issues/166
     new_test_ext().execute_with(|| {
-        let max_skipped_blocks = 3600;
-        for d in (0..max_skipped_blocks).step_by(max_skipped_blocks as usize / 1000) {
+        let max_skipped_blocks = <Test as Config>::MaximumSkippedBlocks::get();
+        for d in (0..max_skipped_blocks).step_by(max_skipped_blocks as usize / 100) {
             // using Multiplier::one() only e^(-vnt) is tested
             NextLengthMultiplier::<Test>::put(Multiplier::one());
             mock::set_last_relay_block_number(1);
@@ -124,6 +121,39 @@ fn test_skipped_block_multiplier_update() {
     });
 }
 
+#[test]
+fn test_max_skipped_block_exceeded() {
+    new_test_ext().execute_with(|| {
+        NextLengthMultiplier::<Test>::put(Multiplier::one());
+        mock::set_last_relay_block_number(1);
+
+        let max_skipped_blocks = <Test as Config>::MaximumSkippedBlocks::get();
+        let relay_data = PersistedValidationData {
+            parent_head: HeadData(vec![]),
+            // The previous relay parent was 10 times greater than the expected MaximumSkippedBlocks.
+            // If the multiplier is updated with that number of skipped blocks
+            // there's should be a significant divergence in the final result.
+            // However, we expect it to be bounded by max_skipped_blocks.
+            relay_parent_number: 1 + 2 + ((max_skipped_blocks * 10) * 2),
+            relay_parent_storage_root: sp_core::H256::zero(),
+            max_pov_size: 0,
+        };
+
+        LengthFeeAdjustment::on_validation_data(&relay_data);
+
+        let mul = NextLengthMultiplier::<Test>::get();
+
+        // calculate expected result using f64::exp and assert on the error rate
+        let target = Multiplier::from(TargetBlockSize::<Test>::get()).to_float();
+        let v = <Test as Config>::AdjustmentVariableBlockSize::get().to_float();
+        let expected_mul =
+            Multiplier::from_float((-1.0 * target * v * max_skipped_blocks as f64).exp());
+
+        //Accepted error is less than 10^(-2)
+        assert_eq_error_rate!(mul, expected_mul, Multiplier::from_inner(10000000000000000));
+    });
+}
+
 #[test]
 fn test_skipped_block_no_prev_data() {
     new_test_ext().execute_with(|| {

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

@@ -303,6 +303,9 @@ parameter_types! {
     // The accepted error is less than 10^(-2) for an expected
     // maximum of 3600 skipped blocks (half a day)
     pub SkippedBlocksNumberTerms: u32 = 3;
+
+    // Maximum acceptable number of skipped parachain blocks.
+    pub MaximumSkippedBlocks: u32 = sugondat_primitives::MAX_SKIPPED_BLOCKS;
 }
 
 impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
@@ -312,6 +315,7 @@ impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
     type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
     type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
     type SkippedBlocksNumberTerms = SkippedBlocksNumberTerms;
+    type MaximumSkippedBlocks = MaximumSkippedBlocks;
     type LastRelayBlockNumberProvider = Runtime;
 }
 

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

@@ -370,6 +370,9 @@ parameter_types! {
     // The accepted error is less than 10^(-2) for an expected
     // maximum of 3600 skipped blocks (half a day)
     pub SkippedBlocksNumberTerms: u32 = 3;
+
+    // Maximum acceptable number of skipped parachain blocks.
+    pub MaximumSkippedBlocks: u32 = sugondat_primitives::MAX_SKIPPED_BLOCKS;
 }
 
 impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
@@ -379,6 +382,7 @@ impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
     type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
     type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
     type SkippedBlocksNumberTerms = SkippedBlocksNumberTerms;
+    type MaximumSkippedBlocks = MaximumSkippedBlocks;
     type LastRelayBlockNumberProvider = Runtime;
 }