Rename Origin (#6020)

* Rename Origin

* fmt

* fixes

* more fixes

* fix

* more fixing

* small fixes

* last touches

* update lockfile for {"substrate"}

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
Co-authored-by: parity-processbot <>

polkadot/runtime/parachains/src/configuration/tests.rs

@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::*;
-use crate::mock::{new_test_ext, Configuration, Origin, ParasShared, Test};
+use crate::mock::{new_test_ext, Configuration, ParasShared, RuntimeOrigin, Test};
 use frame_support::{assert_err, assert_ok};
 
 fn on_new_session(session_index: SessionIndex) -> (HostConfiguration<u32>, HostConfiguration<u32>) {
@@ -48,7 +48,7 @@ fn initializer_on_new_session() {
 	new_test_ext(Default::default()).execute_with(|| {
 		let (prev_config, new_config) = on_new_session(1);
 		assert_eq!(prev_config, new_config);
-		assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
 
 		let (prev_config, new_config) = on_new_session(2);
 		assert_eq!(prev_config, new_config);
@@ -67,7 +67,7 @@ fn config_changes_after_2_session_boundary() {
 		config.validation_upgrade_delay = 100;
 		assert!(old_config != config);
 
-		assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
 
 		// Verify that the current configuration has not changed and that there is a scheduled
 		// change for the SESSION_DELAY sessions in advance.
@@ -96,8 +96,8 @@ fn consecutive_changes_within_one_session() {
 		config.validation_upgrade_cooldown = 100;
 		assert!(old_config != config);
 
-		assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
-		assert_ok!(Configuration::set_validation_upgrade_cooldown(Origin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 100));
 		assert_eq!(Configuration::config(), old_config);
 		assert_eq!(<Configuration as Store>::PendingConfigs::get(), vec![(2, config.clone())]);
 
@@ -125,7 +125,7 @@ fn pending_next_session_but_we_upgrade_once_more() {
 			..initial_config.clone()
 		};
 
-		assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
 		assert_eq!(Configuration::config(), initial_config);
 		assert_eq!(
 			<Configuration as Store>::PendingConfigs::get(),
@@ -136,7 +136,7 @@ fn pending_next_session_but_we_upgrade_once_more() {
 
 		// We are still waiting until the pending configuration is applied and we add another
 		// update.
-		assert_ok!(Configuration::set_validation_upgrade_cooldown(Origin::root(), 99));
+		assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 99));
 
 		// This should result in yet another configiguration change scheduled.
 		assert_eq!(Configuration::config(), initial_config);
@@ -173,7 +173,7 @@ fn scheduled_session_config_update_while_next_session_pending() {
 			..initial_config.clone()
 		};
 
-		assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
 		assert_eq!(Configuration::config(), initial_config);
 		assert_eq!(
 			<Configuration as Store>::PendingConfigs::get(),
@@ -184,8 +184,8 @@ fn scheduled_session_config_update_while_next_session_pending() {
 
 		// The second call should fall into the case where we already have a pending config
 		// update for the scheduled_session, but we want to update it once more.
-		assert_ok!(Configuration::set_validation_upgrade_cooldown(Origin::root(), 99));
-		assert_ok!(Configuration::set_code_retention_period(Origin::root(), 98));
+		assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 99));
+		assert_ok!(Configuration::set_code_retention_period(RuntimeOrigin::root(), 98));
 
 		// This should result in yet another configiguration change scheduled.
 		assert_eq!(Configuration::config(), initial_config);
@@ -213,30 +213,30 @@ fn scheduled_session_config_update_while_next_session_pending() {
 fn invariants() {
 	new_test_ext(Default::default()).execute_with(|| {
 		assert_err!(
-			Configuration::set_max_code_size(Origin::root(), MAX_CODE_SIZE + 1),
+			Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1),
 			Error::<Test>::InvalidNewValue
 		);
 
 		assert_err!(
-			Configuration::set_max_pov_size(Origin::root(), MAX_POV_SIZE + 1),
+			Configuration::set_max_pov_size(RuntimeOrigin::root(), MAX_POV_SIZE + 1),
 			Error::<Test>::InvalidNewValue
 		);
 
 		assert_err!(
-			Configuration::set_max_head_data_size(Origin::root(), MAX_HEAD_DATA_SIZE + 1),
+			Configuration::set_max_head_data_size(RuntimeOrigin::root(), MAX_HEAD_DATA_SIZE + 1),
 			Error::<Test>::InvalidNewValue
 		);
 
 		assert_err!(
-			Configuration::set_chain_availability_period(Origin::root(), 0),
+			Configuration::set_chain_availability_period(RuntimeOrigin::root(), 0),
 			Error::<Test>::InvalidNewValue
 		);
 		assert_err!(
-			Configuration::set_thread_availability_period(Origin::root(), 0),
+			Configuration::set_thread_availability_period(RuntimeOrigin::root(), 0),
 			Error::<Test>::InvalidNewValue
 		);
 		assert_err!(
-			Configuration::set_no_show_slots(Origin::root(), 0),
+			Configuration::set_no_show_slots(RuntimeOrigin::root(), 0),
 			Error::<Test>::InvalidNewValue
 		);
 
@@ -247,20 +247,20 @@ fn invariants() {
 			..Default::default()
 		});
 		assert_err!(
-			Configuration::set_chain_availability_period(Origin::root(), 12),
+			Configuration::set_chain_availability_period(RuntimeOrigin::root(), 12),
 			Error::<Test>::InvalidNewValue
 		);
 		assert_err!(
-			Configuration::set_thread_availability_period(Origin::root(), 12),
+			Configuration::set_thread_availability_period(RuntimeOrigin::root(), 12),
 			Error::<Test>::InvalidNewValue
 		);
 		assert_err!(
-			Configuration::set_minimum_validation_upgrade_delay(Origin::root(), 9),
+			Configuration::set_minimum_validation_upgrade_delay(RuntimeOrigin::root(), 9),
 			Error::<Test>::InvalidNewValue
 		);
 
 		assert_err!(
-			Configuration::set_validation_upgrade_delay(Origin::root(), 0),
+			Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 0),
 			Error::<Test>::InvalidNewValue
 		);
 	});
@@ -270,12 +270,12 @@ fn invariants() {
 fn consistency_bypass_works() {
 	new_test_ext(Default::default()).execute_with(|| {
 		assert_err!(
-			Configuration::set_max_code_size(Origin::root(), MAX_CODE_SIZE + 1),
+			Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1),
 			Error::<Test>::InvalidNewValue
 		);
 
-		assert_ok!(Configuration::set_bypass_consistency_check(Origin::root(), true));
-		assert_ok!(Configuration::set_max_code_size(Origin::root(), MAX_CODE_SIZE + 1));
+		assert_ok!(Configuration::set_bypass_consistency_check(RuntimeOrigin::root(), true));
+		assert_ok!(Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1));
 
 		assert_eq!(
 			Configuration::config().max_code_size,
@@ -339,165 +339,186 @@ fn setting_pending_config_members() {
 		};
 
 		Configuration::set_validation_upgrade_cooldown(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.validation_upgrade_cooldown,
 		)
 		.unwrap();
 		Configuration::set_validation_upgrade_delay(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.validation_upgrade_delay,
 		)
 		.unwrap();
-		Configuration::set_code_retention_period(Origin::root(), new_config.code_retention_period)
+		Configuration::set_code_retention_period(
+			RuntimeOrigin::root(),
+			new_config.code_retention_period,
+		)
+		.unwrap();
+		Configuration::set_max_code_size(RuntimeOrigin::root(), new_config.max_code_size).unwrap();
+		Configuration::set_max_pov_size(RuntimeOrigin::root(), new_config.max_pov_size).unwrap();
+		Configuration::set_max_head_data_size(RuntimeOrigin::root(), new_config.max_head_data_size)
 			.unwrap();
-		Configuration::set_max_code_size(Origin::root(), new_config.max_code_size).unwrap();
-		Configuration::set_max_pov_size(Origin::root(), new_config.max_pov_size).unwrap();
-		Configuration::set_max_head_data_size(Origin::root(), new_config.max_head_data_size)
+		Configuration::set_parathread_cores(RuntimeOrigin::root(), new_config.parathread_cores)
 			.unwrap();
-		Configuration::set_parathread_cores(Origin::root(), new_config.parathread_cores).unwrap();
-		Configuration::set_parathread_retries(Origin::root(), new_config.parathread_retries)
+		Configuration::set_parathread_retries(RuntimeOrigin::root(), new_config.parathread_retries)
 			.unwrap();
 		Configuration::set_group_rotation_frequency(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.group_rotation_frequency,
 		)
 		.unwrap();
 		// This comes out of order to satisfy the validity criteria for the chain and thread
 		// availability periods.
 		Configuration::set_minimum_validation_upgrade_delay(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.minimum_validation_upgrade_delay,
 		)
 		.unwrap();
 		Configuration::set_chain_availability_period(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.chain_availability_period,
 		)
 		.unwrap();
 		Configuration::set_thread_availability_period(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.thread_availability_period,
 		)
 		.unwrap();
-		Configuration::set_scheduling_lookahead(Origin::root(), new_config.scheduling_lookahead)
-			.unwrap();
+		Configuration::set_scheduling_lookahead(
+			RuntimeOrigin::root(),
+			new_config.scheduling_lookahead,
+		)
+		.unwrap();
 		Configuration::set_max_validators_per_core(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.max_validators_per_core,
 		)
 		.unwrap();
-		Configuration::set_max_validators(Origin::root(), new_config.max_validators).unwrap();
-		Configuration::set_dispute_period(Origin::root(), new_config.dispute_period).unwrap();
+		Configuration::set_max_validators(RuntimeOrigin::root(), new_config.max_validators)
+			.unwrap();
+		Configuration::set_dispute_period(RuntimeOrigin::root(), new_config.dispute_period)
+			.unwrap();
 		Configuration::set_dispute_post_conclusion_acceptance_period(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.dispute_post_conclusion_acceptance_period,
 		)
 		.unwrap();
 		Configuration::set_dispute_max_spam_slots(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.dispute_max_spam_slots,
 		)
 		.unwrap();
 		Configuration::set_dispute_conclusion_by_time_out_period(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.dispute_conclusion_by_time_out_period,
 		)
 		.unwrap();
-		Configuration::set_no_show_slots(Origin::root(), new_config.no_show_slots).unwrap();
-		Configuration::set_n_delay_tranches(Origin::root(), new_config.n_delay_tranches).unwrap();
+		Configuration::set_no_show_slots(RuntimeOrigin::root(), new_config.no_show_slots).unwrap();
+		Configuration::set_n_delay_tranches(RuntimeOrigin::root(), new_config.n_delay_tranches)
+			.unwrap();
 		Configuration::set_zeroth_delay_tranche_width(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.zeroth_delay_tranche_width,
 		)
 		.unwrap();
-		Configuration::set_needed_approvals(Origin::root(), new_config.needed_approvals).unwrap();
+		Configuration::set_needed_approvals(RuntimeOrigin::root(), new_config.needed_approvals)
+			.unwrap();
 		Configuration::set_relay_vrf_modulo_samples(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.relay_vrf_modulo_samples,
 		)
 		.unwrap();
 		Configuration::set_max_upward_queue_count(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.max_upward_queue_count,
 		)
 		.unwrap();
-		Configuration::set_max_upward_queue_size(Origin::root(), new_config.max_upward_queue_size)
-			.unwrap();
+		Configuration::set_max_upward_queue_size(
+			RuntimeOrigin::root(),
+			new_config.max_upward_queue_size,
+		)
+		.unwrap();
 		Configuration::set_max_downward_message_size(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.max_downward_message_size,
 		)
 		.unwrap();
 		Configuration::set_ump_service_total_weight(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.ump_service_total_weight,
 		)
 		.unwrap();
 		Configuration::set_max_upward_message_size(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.max_upward_message_size,
 		)
 		.unwrap();
 		Configuration::set_max_upward_message_num_per_candidate(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.max_upward_message_num_per_candidate,
 		)
 		.unwrap();
-		Configuration::set_hrmp_sender_deposit(Origin::root(), new_config.hrmp_sender_deposit)
-			.unwrap();
+		Configuration::set_hrmp_sender_deposit(
+			RuntimeOrigin::root(),
+			new_config.hrmp_sender_deposit,
+		)
+		.unwrap();
 		Configuration::set_hrmp_recipient_deposit(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_recipient_deposit,
 		)
 		.unwrap();
 		Configuration::set_hrmp_channel_max_capacity(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_channel_max_capacity,
 		)
 		.unwrap();
 		Configuration::set_hrmp_channel_max_total_size(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_channel_max_total_size,
 		)
 		.unwrap();
 		Configuration::set_hrmp_max_parachain_inbound_channels(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_max_parachain_inbound_channels,
 		)
 		.unwrap();
 		Configuration::set_hrmp_max_parathread_inbound_channels(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_max_parathread_inbound_channels,
 		)
 		.unwrap();
 		Configuration::set_hrmp_channel_max_message_size(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_channel_max_message_size,
 		)
 		.unwrap();
 		Configuration::set_hrmp_max_parachain_outbound_channels(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_max_parachain_outbound_channels,
 		)
 		.unwrap();
 		Configuration::set_hrmp_max_parathread_outbound_channels(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_max_parathread_outbound_channels,
 		)
 		.unwrap();
 		Configuration::set_hrmp_max_message_num_per_candidate(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.hrmp_max_message_num_per_candidate,
 		)
 		.unwrap();
 		Configuration::set_ump_max_individual_weight(
-			Origin::root(),
+			RuntimeOrigin::root(),
 			new_config.ump_max_individual_weight,
 		)
 		.unwrap();
-		Configuration::set_pvf_checking_enabled(Origin::root(), new_config.pvf_checking_enabled)
+		Configuration::set_pvf_checking_enabled(
+			RuntimeOrigin::root(),
+			new_config.pvf_checking_enabled,
+		)
+		.unwrap();
+		Configuration::set_pvf_voting_ttl(RuntimeOrigin::root(), new_config.pvf_voting_ttl)
 			.unwrap();
-		Configuration::set_pvf_voting_ttl(Origin::root(), new_config.pvf_voting_ttl).unwrap();
 
 		assert_eq!(
 			<Configuration as Store>::PendingConfigs::get(),
@@ -509,7 +530,7 @@ fn setting_pending_config_members() {
 #[test]
 fn non_root_cannot_set_config() {
 	new_test_ext(Default::default()).execute_with(|| {
-		assert!(Configuration::set_validation_upgrade_delay(Origin::signed(1), 100).is_err());
+		assert!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::signed(1), 100).is_err());
 	});
 }
 

polkadot/runtime/parachains/src/hrmp.rs

@@ -241,9 +241,9 @@ pub mod pallet {
 		/// The outer event type.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
-		type Origin: From<crate::Origin>
-			+ From<<Self as frame_system::Config>::Origin>
-			+ Into<Result<crate::Origin, <Self as Config>::Origin>>;
+		type RuntimeOrigin: From<crate::Origin>
+			+ From<<Self as frame_system::Config>::RuntimeOrigin>
+			+ Into<Result<crate::Origin, <Self as Config>::RuntimeOrigin>>;
 
 		/// An interface for reserving deposits for opening channels.
 		///
@@ -465,7 +465,7 @@ pub mod pallet {
 			proposed_max_capacity: u32,
 			proposed_max_message_size: u32,
 		) -> DispatchResult {
-			let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
+			let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
 			Self::init_open_channel(
 				origin,
 				recipient,
@@ -486,7 +486,7 @@ pub mod pallet {
 		/// The channel will be opened only on the next session boundary.
 		#[pallet::weight(<T as Config>::WeightInfo::hrmp_accept_open_channel())]
 		pub fn hrmp_accept_open_channel(origin: OriginFor<T>, sender: ParaId) -> DispatchResult {
-			let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
+			let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
 			Self::accept_open_channel(origin, sender)?;
 			Self::deposit_event(Event::OpenChannelAccepted(sender, origin));
 			Ok(())
@@ -501,7 +501,7 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			channel_id: HrmpChannelId,
 		) -> DispatchResult {
-			let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
+			let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
 			Self::close_channel(origin, channel_id.clone())?;
 			Self::deposit_event(Event::ChannelClosed(origin, channel_id));
 			Ok(())
@@ -567,7 +567,7 @@ pub mod pallet {
 			channel_id: HrmpChannelId,
 			open_requests: u32,
 		) -> DispatchResult {
-			let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
+			let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
 			ensure!(
 				<Self as Store>::HrmpOpenChannelRequestsList::decode_len().unwrap_or_default()
 					as u32 <= open_requests,

polkadot/runtime/parachains/src/hrmp/benchmarking.rs

@@ -66,7 +66,7 @@ fn establish_para_connection<T: Config>(
 	until: ParachainSetupStep,
 ) -> [(ParaId, crate::Origin); 2]
 where
-	<T as frame_system::Config>::Origin: From<crate::Origin>,
+	<T as frame_system::Config>::RuntimeOrigin: From<crate::Origin>,
 {
 	let config = Configuration::<T>::config();
 	let deposit: BalanceOf<T> = config.hrmp_sender_deposit.unique_saturated_into();
@@ -138,7 +138,7 @@ static_assertions::const_assert!(HRMP_MAX_INBOUND_CHANNELS_BOUND < PREFIX_0);
 static_assertions::const_assert!(HRMP_MAX_OUTBOUND_CHANNELS_BOUND < PREFIX_0);
 
 frame_benchmarking::benchmarks! {
-	where_clause { where <T as frame_system::Config>::Origin: From<crate::Origin> }
+	where_clause { where <T as frame_system::Config>::RuntimeOrigin: From<crate::Origin> }
 
 	hrmp_init_open_channel {
 		let sender_id: ParaId = 1u32.into();

polkadot/runtime/parachains/src/initializer.rs

@@ -120,7 +120,7 @@ pub mod pallet {
 		/// A randomness beacon.
 		type Randomness: Randomness<Self::Hash, Self::BlockNumber>;
 		/// An origin which is allowed to force updates to parachains.
-		type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::Origin>;
+		type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
 		/// Weight information for extrinsics in this pallet.
 		type WeightInfo: WeightInfo;
 	}

polkadot/runtime/parachains/src/mock.rs

@@ -92,7 +92,7 @@ impl frame_system::Config for Test {
 	type BlockWeights = BlockWeights;
 	type BlockLength = ();
 	type DbWeight = ();
-	type Origin = Origin;
+	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type Index = u64;
 	type BlockNumber = BlockNumber;
@@ -234,8 +234,8 @@ impl crate::ump::Config for Test {
 }
 
 impl crate::hrmp::Config for Test {
+	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeEvent = RuntimeEvent;
-	type Origin = Origin;
 	type Currency = pallet_balances::Pallet<Test>;
 	type WeightInfo = crate::hrmp::TestWeightInfo;
 }

polkadot/runtime/parachains/src/paras/tests.rs

@@ -26,7 +26,8 @@ use test_helpers::{dummy_head_data, dummy_validation_code};
 use crate::{
 	configuration::HostConfiguration,
 	mock::{
-		new_test_ext, Configuration, MockGenesisConfig, Origin, Paras, ParasShared, System, Test,
+		new_test_ext, Configuration, MockGenesisConfig, Paras, ParasShared, RuntimeOrigin, System,
+		Test,
 	},
 };
 
@@ -1449,7 +1450,10 @@ fn add_trusted_validation_code_inserts_with_no_users() {
 	// with the reference count equal to 0.
 	let validation_code = ValidationCode(vec![1, 2, 3]);
 	new_test_ext(Default::default()).execute_with(|| {
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.clone()
+		));
 		assert_eq!(<Paras as Store>::CodeByHashRefs::get(&validation_code.hash()), 0,);
 	});
 }
@@ -1460,9 +1464,15 @@ fn add_trusted_validation_code_idempotent() {
 	// parameters is a no-op.
 	let validation_code = ValidationCode(vec![1, 2, 3]);
 	new_test_ext(Default::default()).execute_with(|| {
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.clone()
+		));
 		assert_storage_noop!({
-			assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
+			assert_ok!(Paras::add_trusted_validation_code(
+				RuntimeOrigin::root(),
+				validation_code.clone()
+			));
 		});
 	});
 }
@@ -1473,8 +1483,14 @@ fn poke_unused_validation_code_removes_code_cleanly() {
 	// in the storage but has no users will remove it cleanly from the storage.
 	let validation_code = ValidationCode(vec![1, 2, 3]);
 	new_test_ext(Default::default()).execute_with(|| {
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
-		assert_ok!(Paras::poke_unused_validation_code(Origin::root(), validation_code.hash()));
+		assert_ok!(Paras::add_trusted_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.clone()
+		));
+		assert_ok!(Paras::poke_unused_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.hash()
+		));
 
 		assert_eq!(<Paras as Store>::CodeByHashRefs::get(&validation_code.hash()), 0);
 		assert!(!<Paras as Store>::CodeByHash::contains_key(&validation_code.hash()));
@@ -1487,7 +1503,10 @@ fn poke_unused_validation_code_doesnt_remove_code_with_users() {
 	let validation_code = ValidationCode(vec![1, 2, 3]);
 	new_test_ext(Default::default()).execute_with(|| {
 		// First we add the code to the storage.
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.clone()
+		));
 
 		// Then we add a user to the code, say by upgrading.
 		run_to_block(2, None);
@@ -1496,7 +1515,10 @@ fn poke_unused_validation_code_doesnt_remove_code_with_users() {
 
 		// Finally we poke the code, which should not remove it from the storage.
 		assert_storage_noop!({
-			assert_ok!(Paras::poke_unused_validation_code(Origin::root(), validation_code.hash()));
+			assert_ok!(Paras::poke_unused_validation_code(
+				RuntimeOrigin::root(),
+				validation_code.hash()
+			));
 		});
 		check_code_is_stored(&validation_code);
 	});
@@ -1511,7 +1533,7 @@ fn increase_code_ref_doesnt_have_allergy_on_add_trusted_validation_code() {
 	let code = ValidationCode(vec![1, 2, 3]);
 
 	new_test_ext(Default::default()).execute_with(|| {
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(RuntimeOrigin::root(), code.clone()));
 		Paras::increase_code_ref(&code.hash(), &code);
 		Paras::increase_code_ref(&code.hash(), &code);
 		assert!(<Paras as Store>::CodeByHash::contains_key(code.hash()));
@@ -1519,7 +1541,7 @@ fn increase_code_ref_doesnt_have_allergy_on_add_trusted_validation_code() {
 	});
 
 	new_test_ext(Default::default()).execute_with(|| {
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(RuntimeOrigin::root(), code.clone()));
 		Paras::decrease_code_ref(&code.hash());
 		assert!(<Paras as Store>::CodeByHash::contains_key(code.hash()));
 		assert_eq!(<Paras as Store>::CodeByHashRefs::get(code.hash()), 0);
@@ -1547,7 +1569,10 @@ fn add_trusted_validation_code_insta_approval() {
 		..Default::default()
 	};
 	new_test_ext(genesis_config).execute_with(|| {
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.clone()
+		));
 
 		// Then some parachain upgrades it's code with the relay-parent 1.
 		run_to_block(2, None);
@@ -1602,7 +1627,10 @@ fn add_trusted_validation_code_enacts_existing_pvf_vote() {
 		assert!(<Paras as Store>::PvfActiveVoteMap::contains_key(&validation_code.hash()));
 
 		// Then we add a trusted validation code. That should conclude the vote.
-		assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
+		assert_ok!(Paras::add_trusted_validation_code(
+			RuntimeOrigin::root(),
+			validation_code.clone()
+		));
 		assert!(<Paras as Store>::FutureCodeUpgrades::get(&para_id).is_some());
 		assert!(!<Paras as Store>::PvfActiveVoteMap::contains_key(&validation_code.hash()));
 	});

polkadot/runtime/parachains/src/session_info/tests.rs

@@ -19,8 +19,8 @@ use crate::{
 	configuration::HostConfiguration,
 	initializer::SessionChangeNotification,
 	mock::{
-		new_test_ext, Configuration, MockGenesisConfig, Origin, ParasShared, SessionInfo, System,
-		Test,
+		new_test_ext, Configuration, MockGenesisConfig, ParasShared, RuntimeOrigin, SessionInfo,
+		System, Test,
 	},
 	util::take_active_subset,
 };
@@ -109,7 +109,7 @@ fn session_pruning_is_based_on_dispute_period() {
 
 		// changing `dispute_period` works
 		let dispute_period = 5;
-		Configuration::set_dispute_period(Origin::root(), dispute_period).unwrap();
+		Configuration::set_dispute_period(RuntimeOrigin::root(), dispute_period).unwrap();
 
 		// Dispute period does not automatically change
 		let config = Configuration::config();
@@ -124,7 +124,7 @@ fn session_pruning_is_based_on_dispute_period() {
 
 		// Increase dispute period even more
 		let new_dispute_period = 16;
-		Configuration::set_dispute_period(Origin::root(), new_dispute_period).unwrap();
+		Configuration::set_dispute_period(RuntimeOrigin::root(), new_dispute_period).unwrap();
 
 		run_to_block(210, session_changes);
 		assert_eq!(EarliestStoredSession::<Test>::get(), 21 - dispute_period);
@@ -154,7 +154,7 @@ fn session_info_is_based_on_config() {
 		assert_eq!(session.needed_approvals, 3);
 
 		// change some param
-		Configuration::set_needed_approvals(Origin::root(), 42).unwrap();
+		Configuration::set_needed_approvals(RuntimeOrigin::root(), 42).unwrap();
 		// 2 sessions later
 		run_to_block(3, new_session_every_block);
 		let session = Sessions::<Test>::get(&3).unwrap();

polkadot/runtime/parachains/src/ump.rs

@@ -234,7 +234,7 @@ pub mod pallet {
 		type FirstMessageFactorPercent: Get<u64>;
 
 		/// Origin which is allowed to execute overweight messages.
-		type ExecuteOverweightOrigin: EnsureOrigin<Self::Origin>;
+		type ExecuteOverweightOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
 		/// Weight information for extrinsics in this pallet.
 		type WeightInfo: WeightInfo;

polkadot/runtime/parachains/src/ump/tests.rs

@@ -16,8 +16,8 @@
 
 use super::*;
 use crate::mock::{
-	assert_last_event, new_test_ext, take_processed, Configuration, MockGenesisConfig, Origin,
-	System, Test, Ump,
+	assert_last_event, new_test_ext, take_processed, Configuration, MockGenesisConfig,
+	RuntimeOrigin, System, Test, Ump,
 };
 use frame_support::{assert_noop, assert_ok, weights::Weight};
 use std::collections::HashSet;
@@ -296,7 +296,7 @@ fn service_overweight_unknown() {
 	// the next test.
 	new_test_ext(GenesisConfigBuilder::default().build()).execute_with(|| {
 		assert_noop!(
-			Ump::service_overweight(Origin::root(), 0, Weight::from_ref_time(1000)),
+			Ump::service_overweight(RuntimeOrigin::root(), 0, Weight::from_ref_time(1000)),
 			Error::<Test>::UnknownMessageIndex
 		);
 	});
@@ -346,18 +346,18 @@ fn overweight_queue_works() {
 		// Now verify that if we wanted to service this overweight message with less than enough
 		// weight it will fail.
 		assert_noop!(
-			Ump::service_overweight(Origin::root(), 0, Weight::from_ref_time(499)),
+			Ump::service_overweight(RuntimeOrigin::root(), 0, Weight::from_ref_time(499)),
 			Error::<Test>::WeightOverLimit
 		);
 
 		// ... and if we try to service it with just enough weight it will succeed as well.
-		assert_ok!(Ump::service_overweight(Origin::root(), 0, Weight::from_ref_time(500)));
+		assert_ok!(Ump::service_overweight(RuntimeOrigin::root(), 0, Weight::from_ref_time(500)));
 		assert_last_event(Event::OverweightServiced(0, Weight::from_ref_time(500)).into());
 
 		// ... and if we try to service a message with index that doesn't exist it will error
 		// out.
 		assert_noop!(
-			Ump::service_overweight(Origin::root(), 1, Weight::from_ref_time(1000)),
+			Ump::service_overweight(RuntimeOrigin::root(), 1, Weight::from_ref_time(1000)),
 			Error::<Test>::UnknownMessageIndex
 		);
 	});