fee adjustments account for skipped blocks

Author: gabriele-0201

Cargo.lock

@@ -20,6 +20,8 @@ pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk", default-
 sp-runtime = { git = "https://github.com/paritytech/polkadot-sdk", default-features = false, branch = "release-polkadot-v1.4.0" }
 sp-weights = { git = "https://github.com/paritytech/polkadot-sdk", default-features = false, branch = "release-polkadot-v1.4.0"}
 sp-arithmetic = { git = "https://github.com/paritytech/polkadot-sdk", default-features = false, branch = "release-polkadot-v1.4.0"}
+cumulus-pallet-parachain-system = { git = "https://github.com/paritytech/polkadot-sdk.git", branch = "release-polkadot-v1.4.0", default-features = false, features = ["parameterized-consensus-hook",] }
+polkadot-primitives = { git = "https://github.com/paritytech/polkadot-sdk", default-features = false, branch = "release-polkadot-v1.4.0" }
 
 [dev-dependencies]
 sp-io = { git = "https://github.com/paritytech/polkadot-sdk", default-features = false, branch = "release-polkadot-v1.4.0"}
@@ -37,4 +39,6 @@ std = [
     "sp-arithmetic/std",
     "pallet-transaction-payment/std",
     "pallet-balances/std",
+    "cumulus-pallet-parachain-system/std",
+    "polkadot-primitives/std",
 ]

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

@@ -38,13 +38,27 @@ mod tests;
 /// `pallet_transaction_type::Config`.
 ///
 /// `targeted_length_fee_adjustment` is updated at the end of each block inside `on_finalize`
+///
+/// The pallet also implements `cumulus_pallet_parachain_system::OnSystemEvent` which is used to update `NextLenghtMultiplier`
+/// when blocks are skipped, the implementation follows the following formula to update the multiplier:
+///
+/// ```ignore
+/// c_traffic = c_traffic * e^(-target*v*n)
+/// ```
+///
+/// where the exponential is evaluated with the first SkippedBlocksNumberTerms terms, specified in the pallet Config, of the Taylor Series expansion of e^x.
 #[frame_support::pallet]
 pub mod pallet {
 
+    use cumulus_pallet_parachain_system::OnSystemEvent;
     use frame_support::pallet_prelude::*;
     use frame_system::pallet_prelude::*;
     use pallet_transaction_payment::{Multiplier, OnChargeTransaction};
-    use sp_runtime::{traits::Get, FixedPointNumber, Perquintill, SaturatedConversion, Saturating};
+    use polkadot_primitives::v6::PersistedValidationData;
+    use sp_runtime::{
+        traits::{Get, One, Zero},
+        FixedPointNumber, Perquintill, SaturatedConversion, Saturating,
+    };
 
     /// Configure the pallet by specifying the parameters and types on which it depends.
     #[pallet::config]
@@ -60,21 +74,39 @@ pub mod pallet {
         type MinimumMultiplierBlockSize: Get<Multiplier>;
         #[pallet::constant]
         type MaximumMultiplierBlockSize: Get<Multiplier>;
+
+        /// SkippedBlocksNumberTerms indicates the number of terms used in evaluating e^x in the Taylor expansion.
+        /// The number of terms ensures that, given the following parameters, the error will be below a certain value.
+        ///
+        /// t = TargetBlockSize
+        /// v = AdjustmentVariableBlockSize
+        /// n = maximum number of skipped blocks
+        ///
+        /// (1 / (m+1)!) * (n * v * t)^(m + 1) <= err
+        ///
+        /// 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>;
     }
 
     #[pallet::pallet]
     pub struct Pallet<T>(_);
 
-    pub struct NextLengthMultiplierDefualt;
-    impl Get<Multiplier> for NextLengthMultiplierDefualt {
+    pub struct NextLengthMultiplierDefault;
+    impl Get<Multiplier> for NextLengthMultiplierDefault {
         fn get() -> Multiplier {
             Multiplier::saturating_from_integer(1)
         }
     }
 
     #[pallet::storage]
     pub type NextLengthMultiplier<T: Config> =
-        StorageValue<_, Multiplier, ValueQuery, NextLengthMultiplierDefualt>;
+        StorageValue<_, Multiplier, ValueQuery, NextLengthMultiplierDefault>;
 
     pub struct TargetBlockSizeDefault;
     impl Get<Perquintill> for TargetBlockSizeDefault {
@@ -87,6 +119,9 @@ pub mod pallet {
     pub type TargetBlockSize<T: Config> =
         StorageValue<_, Perquintill, ValueQuery, TargetBlockSizeDefault>;
 
+    #[pallet::storage]
+    pub type PrevRelayBlockNumber<T: Config> = StorageValue<_, u32, OptionQuery>;
+
     #[pallet::hooks]
     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
         fn on_initialize(_: BlockNumberFor<T>) -> Weight {
@@ -178,4 +213,69 @@ pub mod pallet {
             multiplier.saturating_mul_int(length_fee)
         }
     }
+
+    impl<T: Config> OnSystemEvent for Pallet<T> {
+        fn on_validation_data(data: &PersistedValidationData) {
+            let relay_block_number = data.relay_parent_number;
+
+            let prev_relay_block_number = PrevRelayBlockNumber::<T>::get();
+            PrevRelayBlockNumber::<T>::put(relay_block_number);
+
+            // if nothing was already present then this is the first block to
+            // be executed with the fee adjustment so nothing should be done
+            let prev_relay_block_number = match prev_relay_block_number {
+                Some(prev) => prev,
+                None => return,
+            };
+
+            // It should never be negative because the relay_block_number is surely
+            // greater than the para_block_number.
+            // 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)`
+            // 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 = Multiplier::saturating_from_integer(n_skipped_blocks);
+            let target_block_size = Multiplier::from(TargetBlockSize::<T>::get());
+            let adjustment_variable = Multiplier::from(T::AdjustmentVariableBlockSize::get());
+
+            let x = adjustment_variable
+                .saturating_mul(target_block_size)
+                .saturating_mul(n_skipped_blocks);
+
+            // terms = sum_i (x^i / i!) where i in 0..=n_terms
+            let mut terms = Multiplier::one().saturating_sub(x);
+
+            let mut fact = Multiplier::one();
+            let mut x_i = x;
+
+            for index in 2..=T::SkippedBlocksNumberTerms::get() {
+                x_i = x_i.saturating_mul(x);
+
+                if x_i == Multiplier::zero() {
+                    // If x_i is zero, the current term and all subsequent terms become useless,
+                    // and therefore all next terms can be skipped.
+                    // This happens when only a few blocks are skipped, making vnt very small
+                    break;
+                }
+
+                fact = fact.saturating_mul(Multiplier::saturating_from_integer(index));
+
+                // (-1)^index
+                terms = match index & 1 {
+                    1 => terms.saturating_sub(x_i.div(fact)),
+                    _ => terms.saturating_add(x_i.div(fact)),
+                };
+            }
+
+            NextLengthMultiplier::<T>::mutate(|multiplier| {
+                *multiplier = multiplier.saturating_mul(terms);
+            });
+        }
+
+        fn on_validation_code_applied() {}
+    }
 }

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

@@ -75,9 +75,15 @@ parameter_types! {
     pub TransactionByteFee: Balance = 333333u64;
     pub MaximumBlockLength: u32 = 5 * 1024 * 1024;
     pub AdjustmentVariableBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 840);
-    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 10u128);
+    pub MinimumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_rational(1, 200u128);
     pub MaximumMultiplierBlockSize: Multiplier = Multiplier::saturating_from_integer(10);
 
+    // TODO: NumberTerms neets to be changed 5
+    // when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    // Accepted error is less than 10^(-2)
+    pub SkippedBlocksNumberTerms: u32 = 3;
+
     pub static WeightToFee: u64 = 1;
     pub static OperationalFeeMultiplier: u8 = 5;
 }
@@ -106,4 +112,5 @@ impl pallet_sugondat_length_fee_adjustment::Config for Test {
     type AdjustmentVariableBlockSize = AdjustmentVariableBlockSize;
     type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
     type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
+    type SkippedBlocksNumberTerms = SkippedBlocksNumberTerms;
 }

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

@@ -2,9 +2,14 @@ use crate::{
     mock::{LengthFeeAdjustment, Test},
     *,
 };
+use cumulus_pallet_parachain_system::OnSystemEvent;
 use pallet_transaction_payment::Multiplier;
-use sp_runtime::BuildStorage;
-use sp_runtime::{traits::Get, FixedPointNumber};
+use polkadot_primitives::{v6::PersistedValidationData, HeadData};
+use sp_runtime::{assert_eq_error_rate, BuildStorage};
+use sp_runtime::{
+    traits::{Get, One},
+    FixedPointNumber,
+};
 use sp_weights::{Weight, WeightToFee};
 
 fn new_test_ext() -> sp_io::TestExternalities {
@@ -46,7 +51,7 @@ fn test_default_next_length_multiplier() {
     new_test_ext().execute_with(|| {
         assert_eq!(
             NextLengthMultiplier::<Test>::get(),
-            NextLengthMultiplierDefualt::get()
+            NextLengthMultiplierDefault::get()
         )
     });
 }
@@ -60,3 +65,67 @@ fn test_default_target_block_size() {
         )
     });
 }
+
+#[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) {
+            // using Multiplier::one() only e^(-vnt) is tested
+            NextLengthMultiplier::<Test>::put(Multiplier::one());
+            PrevRelayBlockNumber::<Test>::put(0);
+
+            // TODO: update with `1 + d`
+            // when updating to asynchronous backing
+            // https://github.com/thrumdev/blobs/issues/166
+            let relay_data = PersistedValidationData {
+                parent_head: HeadData(vec![]),
+                relay_parent_number: 2 + d * 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 * d 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(|| {
+        let relay_parent_number = 156;
+        let prev_multiplier = Multiplier::from(2);
+
+        NextLengthMultiplier::<Test>::put(prev_multiplier);
+
+        let relay_data = PersistedValidationData {
+            parent_head: HeadData(vec![]),
+            relay_parent_number,
+            relay_parent_storage_root: sp_core::H256::zero(),
+            max_pov_size: 0,
+        };
+
+        LengthFeeAdjustment::on_validation_data(&relay_data);
+
+        // PrevRelayBlockNumber should be set to what passed in the argument
+        // as relay_parent_number and NextLengthMultiplier should remain the same
+        assert_eq!(
+            PrevRelayBlockNumber::<Test>::get(),
+            Some(relay_parent_number)
+        );
+        assert_eq!(NextLengthMultiplier::<Test>::get(), prev_multiplier);
+    });
+}

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

@@ -293,6 +293,14 @@ parameter_types! {
     // 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();
+
+    // TODO: Change SkippedBlocksNumberTerms to 5
+    // and keep the expected maximum skipped blocks at half a day,
+    // which is 7200 blocks when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    // The accepted error is less than 10^(-2) for an expected
+    // maximum of 3600 skipped blocks (half a day)
+    pub SkippedBlocksNumberTerms: u32 = 3;
 }
 
 impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
@@ -301,6 +309,7 @@ impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
     type AdjustmentVariableBlockSize = AdjustmentVariableBlockSize;
     type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
     type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
+    type SkippedBlocksNumberTerms = SkippedBlocksNumberTerms;
 }
 
 pub type SlowAdjustingFeeUpdate<R> = TargetedFeeAdjustment<
@@ -335,7 +344,7 @@ parameter_types! {
 impl cumulus_pallet_parachain_system::Config for Runtime {
     type WeightInfo = ();
     type RuntimeEvent = RuntimeEvent;
-    type OnSystemEvent = ();
+    type OnSystemEvent = LengthFeeAdjustment;
     type SelfParaId = parachain_info::Pallet<Runtime>;
     type OutboundXcmpMessageSource = XcmpQueue;
     type DmpQueue = frame_support::traits::EnqueueWithOrigin<MessageQueue, RelayOrigin>;

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

@@ -360,6 +360,14 @@ parameter_types! {
     // 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();
+
+    // TODO: Change SkippedBlocksNumberTerms to 5
+    // and keep the expected maximum skipped blocks at half a day,
+    // which is 7200 blocks when updating to asynchronous backing
+    // https://github.com/thrumdev/blobs/issues/166
+    // The accepted error is less than 10^(-2) for an expected
+    // maximum of 3600 skipped blocks (half a day)
+    pub SkippedBlocksNumberTerms: u32 = 3;
 }
 
 impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
@@ -368,6 +376,7 @@ impl pallet_sugondat_length_fee_adjustment::Config for Runtime {
     type AdjustmentVariableBlockSize = AdjustmentVariableBlockSize;
     type MaximumMultiplierBlockSize = MaximumMultiplierBlockSize;
     type MinimumMultiplierBlockSize = MinimumMultiplierBlockSize;
+    type SkippedBlocksNumberTerms = SkippedBlocksNumberTerms;
 }
 
 pub type SlowAdjustingFeeUpdate<R> = TargetedFeeAdjustment<
@@ -402,7 +411,7 @@ parameter_types! {
 impl cumulus_pallet_parachain_system::Config for Runtime {
     type WeightInfo = ();
     type RuntimeEvent = RuntimeEvent;
-    type OnSystemEvent = ();
+    type OnSystemEvent = LengthFeeAdjustment;
     type SelfParaId = parachain_info::Pallet<Runtime>;
     type OutboundXcmpMessageSource = XcmpQueue;
     type DmpQueue = frame_support::traits::EnqueueWithOrigin<MessageQueue, RelayOrigin>;