add fees consts

runtime/common/src/fees.rs

@@ -20,10 +20,10 @@
 ///
 /// When the current block's weight and length are below the targeted thresholds, no fees are charged,
 /// as the weight-to-fee conversion results in zero. Once the block's weight and length exceed these
-/// targets, the weight-to-fee conversion maps 5 (5cG) to a base extrinsic weight.
+/// targets, the weight-to-fee conversion maps BASE_EXTRINSIC_WEIGHT_COST to a base extrinsic weight.
 /// Additionally, a fee is applied based on the length of the extrinsic and is mapped affinely:
-/// 2_000 (20G) corresponds to an extrinsic length of 3.5 kilobytes and will be applied only if the extrinsic
-/// exceeds 256 bytes or if the block target in weight or length is surpassed.
+/// 2_000 (20G) corresponds to an extrinsic length of BYTES_PER_UNIT*10 plus the BASE_EXTRINSIC_LENGTH_COST and will be applied only if the extrinsic
+/// exceeds MAX_EXTRINSIC_LENGTH bytes or if the block target in weight or length is surpassed.
 ///
 /// To further deter abuse, if the previous block's weight or length  the target thresholds,
 /// the chain increases the fees by multiplying the transaction weight with a `FeeMultiplier`. For each
@@ -76,9 +76,15 @@ where
     ///
     /// This function calculates the fee based on the length of the transaction in bytes.
     /// If the current block weight and length are less than a fraction of the max block weight and length, the fee multiplier is one,
-    /// and the extrinsic length is less than 256 bytes, no fees are applied. Otherwise, it calculates the fee based on the length in bytes.
+    /// and the extrinsic length is less than MAX_EXTRINSIC_LENGTH bytes, no fees are applied. Otherwise, it calculates the fee based on the length in bytes.
     #[cfg(not(feature = "constant-fees"))]
     fn weight_to_fee(length_in_bytes: &Weight) -> Self::Balance {
+        // The extrinsic overhead for a remark is approximately 110 bytes.
+        // This leaves 146 bytes available for the actual remark content.
+        const MAX_EXTRINSIC_LENGTH: u64 = 256;
+        const BYTES_PER_UNIT: u64 = 350;
+        const BASE_EXTRINSIC_LENGTH_COST: u64 = 5;
+
         let weights = Runtime::BlockWeights::get();
         let fee_multiplier = pallet_transaction_payment::Pallet::<Runtime>::next_fee_multiplier();
         let normal_max_weight = weights
@@ -90,20 +96,19 @@ where
         let length = Runtime::BlockLength::get();
         let normal_max_length = *length.max.get(DispatchClass::Normal) as u64;
         let current_block_length = <frame_system::Pallet<Runtime>>::all_extrinsics_len() as u64;
-        // The extrinsic overhead for a remark is approximately 110 bytes.
-        // This leaves 146 bytes available for the actual remark content.
-        let max_extrinsic_length = 256;
 
         if current_block_weight
             .get(DispatchClass::Normal)
             .all_lt(Target::get() * normal_max_weight)
             && current_block_length < (Target::get() * normal_max_length)
             && fee_multiplier.is_one()
-            && length_in_bytes.ref_time() < max_extrinsic_length
+            && length_in_bytes.ref_time() < MAX_EXTRINSIC_LENGTH
         {
             0u32.into()
         } else {
-            Self::Balance::saturated_from(length_in_bytes.ref_time() / 350u64 + 5u64)
+            Self::Balance::saturated_from(
+                length_in_bytes.ref_time() / BYTES_PER_UNIT + BASE_EXTRINSIC_LENGTH_COST,
+            )
         }
     }
 
@@ -170,7 +175,8 @@ where
             }]
         } else {
             // The extrinsic base weight (smallest non-zero weight) is mapped to 5 cents
-            let p: Self::Balance = 5u64.into();
+            const BASE_EXTRINSIC_WEIGHT_COST: u64 = 5;
+            let p: Self::Balance = BASE_EXTRINSIC_WEIGHT_COST.into();
             let q: Self::Balance =
                 Self::Balance::from(weights.get(DispatchClass::Normal).base_extrinsic.ref_time());
             smallvec![WeightToFeeCoefficient {