Fix #235 allow remark in prod with a limit on extrinsic size for free transaction

• Allow the remark extrinsic on all chains.
• Set an extrinsic length limit of 256 bytes for now. Beyond this limit, users will start paying fees proportional to the length. With an overhead of 110 bytes, this allows for a remark of up to 146 bytes.
• Adjust the fee constant for fee computation: all extrinsics should be under this limit, except for the runtime upgrade (approximately 700 bytes), which will currently cost 20 ĞDev. Spamming the block at once (e.g., submitting one massive remark that fills the entire block) will cost 115 ĞDev.
• Spamming with "free" remarks: 1 block allows for up to 5 242 880 bytes, of which 3 932 160 bytes are allocated for normal dispatch. With a block fullness target of 25% for normal dispatch (weight or length), this leaves 983 040 bytes available, allowing for approximately 3 840 remarks. After this, fees will be applied, taking into account both weight and length for any length even shorter than 256 bytes (one remark of 256 bytes (overhead + data) will cost 10 mĞDev).

runtime/common/src/fees.rs

@@ -61,8 +61,8 @@ where
     /// Function to convert weight to fee when "constant-fees" feature is not enabled.
     ///
     /// 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 and the fee multiplier is one,
-    /// it returns a zero fee. Otherwise, it calculates the fee based on the length 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.
     #[cfg(not(feature = "constant-fees"))]
     fn weight_to_fee(length_in_bytes: &Weight) -> Self::Balance {
         let weights = Runtime::BlockWeights::get();
@@ -76,16 +76,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;
+        // One remark extrinsic overhead is approximately 110 bytes
+        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
         {
             0u32.into()
         } else {
-            Self::Balance::saturated_from(length_in_bytes.ref_time() / 100u64)
+            Self::Balance::saturated_from(length_in_bytes.ref_time() / 10u64)
         }
     }