CheckWeight: Take transaction length into account during validation (#9907)

During validation of extrinsics we currently check that the benchmarked
weight does not exceed the overall block limit for the given extrinsic
class. For the proof weight, this should also take into account the
length of the transaction. This creates parity with the checks we
already do at extrinsic application time where we take the length [into
account](https://github.com/paritytech/polkadot-sdk/blob/7086502b242c7984a13e198d2373e69a640e5c58/substrate/frame/system/src/extensions/check_weight.rs#L166-L166).

---------

Co-authored-by: cmd[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Bastian Köcher <[email protected]>

Author: 3 people

prdoc/pr_9907.prdoc

@@ -0,0 +1,7 @@
+title: 'CheckWeight: Take transaction length into account during validation'
+doc:
+- audience: Runtime Dev
+  description: The `CheckWeight` extension now takes the length into account when checking whether a transaction fits into a block at validation time.
+crates:
+- name: frame-system
+  bump: patch

substrate/frame/system/src/extensions/check_weight.rs

@@ -50,10 +50,12 @@ where
 	/// with given `DispatchClass` can have.
 	fn check_extrinsic_weight(
 		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
 	) -> Result<(), TransactionValidityError> {
 		let max = T::BlockWeights::get().get(info.class).max_extrinsic;
+		let total_weight_including_length = info.total_weight().add_proof_size(len as u64);
 		match max {
-			Some(max) if info.total_weight().any_gt(max) => {
+			Some(max) if total_weight_including_length.any_gt(max) => {
 				log::debug!(
 					target: LOG_TARGET,
 					"Extrinsic {} is greater than the max extrinsic {}",
@@ -111,7 +113,7 @@ where
 		// during validation we skip block limit check. Since the `validate_transaction`
 		// call runs on an empty block anyway, by this we prevent `on_initialize` weight
 		// consumption from causing false negatives.
-		Self::check_extrinsic_weight(info)?;
+		Self::check_extrinsic_weight(info, len)?;
 
 		Ok((Default::default(), next_len))
 	}
@@ -442,7 +444,7 @@ mod tests {
 			assert_eq!(block_weight_limit(), Weight::from_parts(1024, u64::MAX));
 			assert_eq!(System::block_weight().total(), block_weight_limit().set_proof_size(0));
 			// Checking single extrinsic should not take current block weight into account.
-			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&rest_operational), Ok(()));
+			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&rest_operational, len), Ok(()));
 		});
 	}
 
@@ -504,7 +506,10 @@ mod tests {
 				InvalidTransaction::ExhaustsResources
 			);
 			// Even with full block, validity of single transaction should be correct.
-			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&dispatch_operational), Ok(()));
+			assert_eq!(
+				CheckWeight::<Test>::check_extrinsic_weight(&dispatch_operational, len),
+				Ok(())
+			);
 		});
 	}
 
@@ -890,7 +895,7 @@ mod tests {
 			assert_ok!(CheckWeight::<Test>::do_prepare(&mandatory, len, next_len));
 			assert_eq!(block_weight_limit(), Weight::from_parts(1024, u64::MAX));
 			assert_eq!(System::block_weight().total(), Weight::from_parts(1024 + 768, 0));
-			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&mandatory), Ok(()));
+			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&mandatory, len), Ok(()));
 		});
 	}
 
@@ -947,6 +952,66 @@ mod tests {
 		);
 	}
 
+	#[test]
+	fn check_extrinsic_proof_weight_includes_length() {
+		new_test_ext().execute_with(|| {
+			// Test that check_extrinsic_weight properly includes length in proof size check
+			let weights = block_weights();
+			let max_extrinsic = weights.get(DispatchClass::Normal).max_extrinsic.unwrap();
+
+			let max_proof_size = max_extrinsic.proof_size() as usize;
+			// Extrinsic weight that fits without length
+			let info = DispatchInfo {
+				call_weight: max_extrinsic.set_proof_size(0),
+				class: DispatchClass::Normal,
+				..Default::default()
+			};
+
+			// With zero length, should succeed
+			assert_ok!(CheckWeight::<Test>::check_extrinsic_weight(&info, 0));
+
+			// With small length, should succeed
+			assert_ok!(CheckWeight::<Test>::check_extrinsic_weight(&info, 100));
+
+			// With small length, should succeed
+			assert_ok!(CheckWeight::<Test>::check_extrinsic_weight(&info, max_proof_size));
+
+			// One byte above limit, should fail
+			assert_err!(
+				CheckWeight::<Test>::check_extrinsic_weight(&info, max_proof_size + 1),
+				InvalidTransaction::ExhaustsResources
+			);
+
+			// Now test an extrinsic that's at the limit for proof size
+			let info_at_limit = DispatchInfo {
+				call_weight: max_extrinsic,
+				class: DispatchClass::Normal,
+				..Default::default()
+			};
+
+			// At limit with zero length should succeed
+			assert_ok!(CheckWeight::<Test>::check_extrinsic_weight(&info_at_limit, 0));
+
+			// Over limit when length is added should fail
+			assert_err!(
+				CheckWeight::<Test>::check_extrinsic_weight(&info_at_limit, 1),
+				InvalidTransaction::ExhaustsResources
+			);
+
+			// Test with very large length (near usize::MAX on 32-bit systems)
+			let info_zero = DispatchInfo {
+				call_weight: Weight::zero(),
+				class: DispatchClass::Normal,
+				..Default::default()
+			};
+			// Should handle large lengths gracefully via saturating conversion
+			let large_len = usize::MAX;
+			let result = CheckWeight::<Test>::check_extrinsic_weight(&info_zero, large_len);
+			// This should fail because u64::MAX proof size exceeds limits
+			assert_err!(result, InvalidTransaction::ExhaustsResources);
+		});
+	}
+
 	#[test]
 	fn proof_size_includes_length() {
 		let maximum_weight = BlockWeights::builder()