Removed deprecated ValidateUnsigned

Author: antkve

pallets/transaction-storage/src/lib.rs

@@ -344,7 +344,22 @@ pub mod pallet {
 		#[pallet::call_index(0)]
 		#[pallet::weight(T::WeightInfo::store(data.len() as u32))]
 		#[pallet::feeless_if(|origin: &OriginFor<T>, data: &Vec<u8>| -> bool { /*TODO: add here correct validation */ true })]
-		pub fn store(_origin: OriginFor<T>, data: Vec<u8>) -> DispatchResult {
+		#[pallet::authorize(|_source, data| {
+			Pallet::<T>::to_validity_with_refund(
+				Pallet::<T>::check_unsigned_store(data.as_slice(), CheckContext::Validate),
+			)
+		})]
+		#[pallet::weight_of_authorize(Weight::zero())]
+		pub fn store(origin: OriginFor<T>, data: Vec<u8>) -> DispatchResult {
+			let is_authorized = matches!(
+				origin.into(),
+				Ok(frame_system::RawOrigin::Authorized)
+			);
+			if is_authorized {
+				Self::check_unsigned_store(data.as_slice(), CheckContext::PreDispatch)
+					.map_err(Self::dispatch_error_from_validity)?;
+			}
+
 			// In the case of a regular unsigned transaction, this should have been checked by
 			// pre_dispatch. In the case of a regular signed transaction, this should have been
 			// checked by pre_dispatch_signed.
@@ -395,11 +410,28 @@ pub mod pallet {
 		/// O(1).
 		#[pallet::call_index(1)]
 		#[pallet::weight(T::WeightInfo::renew())]
+		#[pallet::authorize(|_source, block, index| {
+			Pallet::<T>::to_validity_with_refund(Pallet::<T>::check_unsigned_renew(
+				block,
+				index,
+				CheckContext::Validate,
+			))
+		})]
+		#[pallet::weight_of_authorize(Weight::zero())]
 		pub fn renew(
-			_origin: OriginFor<T>,
+			origin: OriginFor<T>,
 			block: BlockNumberFor<T>,
 			index: u32,
 		) -> DispatchResultWithPostInfo {
+			let is_authorized = matches!(
+				origin.into(),
+				Ok(frame_system::RawOrigin::Authorized)
+			);
+			if is_authorized {
+				Self::check_unsigned_renew(&block, &index, CheckContext::PreDispatch)
+					.map_err(Self::dispatch_error_from_validity)?;
+			}
+
 			let info = Self::transaction_info(block, index).ok_or(Error::<T>::RenewedNotFound)?;
 
 			// In the case of a regular unsigned transaction, this should have been checked by
@@ -531,6 +563,12 @@ pub mod pallet {
 		/// when successful.
 		#[pallet::call_index(5)]
 		#[pallet::weight(T::WeightInfo::remove_expired_account_authorization())]
+		#[pallet::authorize(|_source, who| {
+			Pallet::<T>::to_validity_with_refund(
+				Pallet::<T>::check_unsigned_remove_expired_account(who, CheckContext::Validate),
+			)
+		})]
+		#[pallet::weight_of_authorize(Weight::zero())]
 		pub fn remove_expired_account_authorization(
 			_origin: OriginFor<T>,
 			who: T::AccountId,
@@ -551,6 +589,12 @@ pub mod pallet {
 		/// when successful.
 		#[pallet::call_index(6)]
 		#[pallet::weight(T::WeightInfo::remove_expired_preimage_authorization())]
+		#[pallet::authorize(|_source, hash| {
+			Pallet::<T>::to_validity_with_refund(
+				Pallet::<T>::check_unsigned_remove_expired_preimage(hash, CheckContext::Validate),
+			)
+		})]
+		#[pallet::weight_of_authorize(Weight::zero())]
 		pub fn remove_expired_preimage_authorization(
 			_origin: OriginFor<T>,
 			content_hash: ContentHash,
@@ -719,25 +763,20 @@ pub mod pallet {
 		}
 	}
 
-	#[pallet::validate_unsigned]
-	impl<T: Config> ValidateUnsigned for Pallet<T> {
-		type Call = Call<T>;
-
-		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
-			Self::check_unsigned(call, CheckContext::Validate)?.ok_or(IMPOSSIBLE.into())
+	impl<T: Config> Pallet<T> {
+		fn to_validity_with_refund(
+			result: Result<Option<ValidTransaction>, TransactionValidityError>,
+		) -> Result<(ValidTransaction, Weight), TransactionValidityError> {
+			let validity =
+				result?.ok_or(TransactionValidityError::Invalid(IMPOSSIBLE))?;
+			Ok((validity, Weight::zero()))
 		}
 
-		fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
-			// Allow inherents here.
-			if Self::is_inherent(call) {
-				return Ok(());
-			}
-
-			Self::check_unsigned(call, CheckContext::PreDispatch).map(|_| ())
+		fn dispatch_error_from_validity(error: TransactionValidityError) -> DispatchError {
+			let message: &'static str = error.into();
+			DispatchError::Other(message)
 		}
-	}
 
-	impl<T: Config> Pallet<T> {
 		/// Returns `true` if the system is beyond the given expiration point.
 		fn expired(expiration: BlockNumberFor<T>) -> bool {
 			let now = frame_system::Pallet::<T>::block_number();
@@ -1013,25 +1052,34 @@ pub mod pallet {
 			}))
 		}
 
-		fn check_unsigned(
-			call: &Call<T>,
+		fn check_unsigned_store(
+			data: &[u8],
 			context: CheckContext,
 		) -> Result<Option<ValidTransaction>, TransactionValidityError> {
-			match call {
-				Call::<T>::store { data } => Self::check_store_renew_unsigned(
+			Self::check_store_renew_unsigned(
 					data.len(),
 					|| sp_io::hashing::blake2_256(data),
 					context,
-				),
-				Call::<T>::renew { block, index } => {
+			)
+		}
+
+		fn check_unsigned_renew(
+			block: &BlockNumberFor<T>,
+			index: &u32,
+			context: CheckContext,
+		) -> Result<Option<ValidTransaction>, TransactionValidityError> {
 					let info = Self::transaction_info(*block, *index).ok_or(RENEWED_NOT_FOUND)?;
 					Self::check_store_renew_unsigned(
 						info.size as usize,
 						|| info.content_hash.into(),
 						context,
 					)
-				},
-				Call::<T>::remove_expired_account_authorization { who } => {
+		}
+
+		fn check_unsigned_remove_expired_account(
+			who: &T::AccountId,
+			context: CheckContext,
+		) -> Result<Option<ValidTransaction>, TransactionValidityError> {
 					Self::check_authorization_expired(AuthorizationScope::Account(who.clone()))?;
 					Ok(context.want_valid_transaction().then(|| {
 						ValidTransaction::with_tag_prefix(
@@ -1042,9 +1090,13 @@ pub mod pallet {
 						.longevity(T::RemoveExpiredAuthorizationLongevity::get())
 						.into()
 					}))
-				},
-				Call::<T>::remove_expired_preimage_authorization { content_hash } => {
-					Self::check_authorization_expired(AuthorizationScope::Preimage(*content_hash))?;
+		}
+
+		fn check_unsigned_remove_expired_preimage(
+			hash: &ContentHash,
+			context: CheckContext,
+		) -> Result<Option<ValidTransaction>, TransactionValidityError> {
+					Self::check_authorization_expired(AuthorizationScope::Preimage(*hash))?;
 					Ok(context.want_valid_transaction().then(|| {
 						ValidTransaction::with_tag_prefix(
 							"TransactionStorageRemoveExpiredPreimageAuthorization",
@@ -1054,7 +1106,20 @@ pub mod pallet {
 						.longevity(T::RemoveExpiredAuthorizationLongevity::get())
 						.into()
 					}))
-				},
+		}
+
+		fn check_unsigned(
+			call: &Call<T>,
+			context: CheckContext,
+		) -> Result<Option<ValidTransaction>, TransactionValidityError> {
+			match call {
+				Call::<T>::store { data } => Self::check_unsigned_store(data.as_slice(), context),
+				Call::<T>::renew { block, index } =>
+					Self::check_unsigned_renew(block, index, context),
+				Call::<T>::remove_expired_account_authorization { who } =>
+					Self::check_unsigned_remove_expired_account(who, context),
+				Call::<T>::remove_expired_preimage_authorization { hash } =>
+					Self::check_unsigned_remove_expired_preimage(hash, context),
 				_ => Err(InvalidTransaction::Call.into()),
 			}
 		}

pallets/transaction-storage/src/tests.rs

@@ -29,7 +29,9 @@ use polkadot_sdk_frame::{
 	prelude::{frame_system::RawOrigin, *},
 	testing_prelude::*,
 };
+use frame_support::traits::Authorize;
 use sp_transaction_storage_proof::{random_chunk, registration::build_proof, CHUNK_SIZE};
+use sp_runtime::transaction_validity::TransactionSource;
 
 type Call = super::Call<Test>;
 type Error = super::Error<Test>;
@@ -104,23 +106,30 @@ fn uses_preimage_authorization() {
 			AuthorizationExtent { transactions: 1, bytes: 2002 }
 		);
 		let call = Call::store { data: vec![1; 2000] };
-		assert_noop!(TransactionStorage::pre_dispatch(&call), InvalidTransaction::Payment);
+		assert_noop!(
+			call.authorize(TransactionSource::External).unwrap(),
+			InvalidTransaction::Payment
+		);
 		let call = Call::store { data };
-		assert_ok!(TransactionStorage::pre_dispatch(&call));
+		assert_ok!(call.authorize(TransactionSource::External).unwrap());
 		assert_eq!(
 			TransactionStorage::preimage_authorization_extent(hash),
 			AuthorizationExtent { transactions: 0, bytes: 0 }
 		);
-		assert_ok!(Into::<RuntimeCall>::into(call).dispatch(RuntimeOrigin::none()));
+		assert_ok!(Into::<RuntimeCall>::into(call).dispatch(RawOrigin::Authorized.into()));
 		run_to_block(3, || None);
 		let call = Call::renew { block: 1, index: 0 };
-		assert_noop!(TransactionStorage::pre_dispatch(&call), InvalidTransaction::Payment);
+		assert_noop!(
+			call.authorize(TransactionSource::External).unwrap(),
+			InvalidTransaction::Payment
+		);
 		assert_ok!(TransactionStorage::authorize_preimage(RuntimeOrigin::root(), hash, 2000));
-		assert_ok!(TransactionStorage::pre_dispatch(&call));
+		assert_ok!(call.authorize(TransactionSource::External).unwrap());
 		assert_eq!(
 			TransactionStorage::preimage_authorization_extent(hash),
 			AuthorizationExtent { transactions: 0, bytes: 0 }
 		);
+		assert_ok!(Into::<RuntimeCall>::into(call).dispatch(RawOrigin::Authorized.into()));
 	});
 }
 
@@ -292,9 +301,12 @@ fn expired_authorization_clears() {
 		// Can't remove too early
 		run_to_block(10, || None);
 		let remove_call = Call::remove_expired_account_authorization { who };
-		assert_noop!(TransactionStorage::pre_dispatch(&remove_call), AUTHORIZATION_NOT_EXPIRED);
 		assert_noop!(
-			Into::<RuntimeCall>::into(remove_call.clone()).dispatch(RuntimeOrigin::none()),
+			remove_call.authorize(TransactionSource::External).unwrap(),
+			AUTHORIZATION_NOT_EXPIRED
+		);
+		assert_noop!(
+			Into::<RuntimeCall>::into(remove_call.clone()).dispatch(RawOrigin::Authorized.into()),
 			Error::AuthorizationNotExpired,
 		);
 
@@ -308,8 +320,8 @@ fn expired_authorization_clears() {
 			InvalidTransaction::Payment,
 		);
 		// Anyone can remove it
-		assert_ok!(TransactionStorage::pre_dispatch(&remove_call));
-		assert_ok!(Into::<RuntimeCall>::into(remove_call).dispatch(RuntimeOrigin::none()));
+		assert_ok!(remove_call.authorize(TransactionSource::External).unwrap());
+		assert_ok!(Into::<RuntimeCall>::into(remove_call).dispatch(RawOrigin::Authorized.into()));
 		System::assert_has_event(RuntimeEvent::TransactionStorage(
 			Event::ExpiredAccountAuthorizationRemoved { who },
 		));

runtimes/bulletin-westend/tests/tests.rs

@@ -122,6 +122,39 @@ fn construct_and_apply_extrinsic(
 	bulletin_westend_runtime::Executive::apply_extrinsic(xt)
 }
 
+fn construct_unsigned_extrinsic(call: RuntimeCall) -> UncheckedExtrinsic {
+	let inner = (
+		frame_system::AuthorizeCall::<Runtime>::new(),
+		frame_system::CheckNonZeroSender::<Runtime>::new(),
+		frame_system::CheckSpecVersion::<Runtime>::new(),
+		frame_system::CheckTxVersion::<Runtime>::new(),
+		frame_system::CheckGenesis::<Runtime>::new(),
+		frame_system::CheckEra::<Runtime>::from(sp_runtime::generic::Era::immortal()),
+		frame_system::CheckNonce::<Runtime>::from(0u32),
+		frame_system::CheckWeight::<Runtime>::new(),
+		pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(0u128),
+		bulletin_westend_runtime::ValidateSigned,
+		frame_metadata_hash_extension::CheckMetadataHash::<Runtime>::new(false),
+	);
+	let tx_ext: TxExtension =
+		cumulus_pallet_weight_reclaim::StorageWeightReclaim::<Runtime, _>::from(inner);
+	UncheckedExtrinsic::new_transaction(call, tx_ext)
+}
+
+fn construct_and_apply_unsigned_extrinsic(call: RuntimeCall) -> ApplyExtrinsicResult {
+	let dispatch_info = call.get_dispatch_info();
+	let xt = construct_unsigned_extrinsic(call);
+	let xt_len = xt.encode().len();
+	tracing::info!(
+		"Applying unsigned extrinsic: class={:?} pays_fee={:?} weight={:?} encoded_len={} bytes",
+		dispatch_info.class,
+		dispatch_info.pays_fee,
+		dispatch_info.total_weight(),
+		xt_len
+	);
+	bulletin_westend_runtime::Executive::apply_extrinsic(xt)
+}
+
 #[test]
 fn transaction_storage_runtime_sizes() {
 	sp_io::TestExternalities::new(RuntimeGenesisConfig::default().build_storage().unwrap())
@@ -203,6 +236,41 @@ fn transaction_storage_runtime_sizes() {
 		});
 }
 
+#[test]
+fn transaction_storage_unsigned_preimage_store_works() {
+	use bulletin_westend_runtime as runtime;
+	use bulletin_westend_runtime::BuildStorage;
+	use frame_support::assert_ok;
+	use pallet_transaction_storage::{AuthorizationExtent, Call as TxStorageCall};
+
+	sp_io::TestExternalities::new(
+		runtime::RuntimeGenesisConfig::default().build_storage().unwrap(),
+	)
+	.execute_with(|| {
+		advance_block();
+
+		let data = vec![7u8; 2000];
+		let hash = sp_io::hashing::blake2_256(&data);
+		assert_ok!(runtime::TransactionStorage::authorize_preimage(
+			RuntimeOrigin::root(),
+			hash,
+			data.len() as u64,
+		));
+
+		let res = construct_and_apply_unsigned_extrinsic(RuntimeCall::TransactionStorage(
+			TxStorageCall::<Runtime>::store { data },
+		));
+		assert_ok!(res);
+		assert_ok!(res.unwrap());
+
+		assert_eq!(
+			runtime::TransactionStorage::preimage_authorization_extent(hash),
+			AuthorizationExtent { transactions: 0, bytes: 0 },
+		);
+	});
+}
+
+
 /// Test maximum write throughput: 8 transactions of 1 MiB each in a single block (8 MiB total).
 #[test]
 fn transaction_storage_max_throughput_per_block() {