Whitelist pallet preimage provider upgrade (#12834)

* whitelist preimage provider upgrade

* rustdocs unresolved link error fix

* ".git/.scripts/bench-bot.sh" pallet dev pallet_whitelist

* PreimageHash alias, remove type annotation

Co-authored-by: command-bot <>

substrate/bin/node/runtime/src/lib.rs

@@ -1544,7 +1544,7 @@ impl pallet_whitelist::Config for Runtime {
 	type RuntimeCall = RuntimeCall;
 	type WhitelistOrigin = EnsureRoot<AccountId>;
 	type DispatchWhitelistedOrigin = EnsureRoot<AccountId>;
-	type PreimageProvider = Preimage;
+	type Preimages = Preimage;
 	type WeightInfo = pallet_whitelist::weights::SubstrateWeight<Runtime>;
 }
 

substrate/frame/whitelist/src/benchmarking.rs

@@ -21,10 +21,7 @@
 
 use super::*;
 use frame_benchmarking::benchmarks;
-use frame_support::{
-	ensure,
-	traits::{EnsureOrigin, Get, PreimageRecipient},
-};
+use frame_support::{ensure, traits::EnsureOrigin};
 
 #[cfg(test)]
 use crate::Pallet as Whitelist;
@@ -40,7 +37,7 @@ benchmarks! {
 			"call not whitelisted"
 		);
 		ensure!(
-			T::PreimageProvider::preimage_requested(&call_hash),
+			T::Preimages::is_requested(&call_hash),
 			"preimage not requested"
 		);
 	}
@@ -57,7 +54,7 @@ benchmarks! {
 			"whitelist not removed"
 		);
 		ensure!(
-			!T::PreimageProvider::preimage_requested(&call_hash),
+			!T::Preimages::is_requested(&call_hash),
 			"preimage still requested"
 		);
 	}
@@ -66,30 +63,30 @@ benchmarks! {
 	// If the resulting weight is too big, maybe it worth having a weight which depends
 	// on the size of the call, with a new witness in parameter.
 	dispatch_whitelisted_call {
-		let origin = T::DispatchWhitelistedOrigin::successful_origin();
 		// NOTE: we remove `10` because we need some bytes to encode the variants and vec length
-		let remark_len = <T::PreimageProvider as PreimageRecipient<_>>::MaxSize::get() - 10;
-		let remark = sp_std::vec![1u8; remark_len as usize];
+		let n in 1 .. T::Preimages::MAX_LENGTH as u32 - 10;
 
+		let origin = T::DispatchWhitelistedOrigin::successful_origin();
+		let remark = sp_std::vec![1u8; n as usize];
 		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark }.into();
 		let call_weight = call.get_dispatch_info().weight;
 		let encoded_call = call.encode();
-		let call_hash = T::Hashing::hash(&encoded_call[..]);
+		let call_encoded_len = encoded_call.len() as u32;
+		let call_hash = call.blake2_256().into();
 
 		Pallet::<T>::whitelist_call(origin.clone(), call_hash)
 			.expect("whitelisting call must be successful");
 
-		let encoded_call = encoded_call.try_into().expect("encoded_call must be small enough");
-		T::PreimageProvider::note_preimage(encoded_call);
+		T::Preimages::note(encoded_call.into()).unwrap();
 
-	}: _<T::RuntimeOrigin>(origin, call_hash, call_weight)
+	}: _<T::RuntimeOrigin>(origin, call_hash, call_encoded_len, call_weight)
 	verify {
 		ensure!(
 			!WhitelistedCall::<T>::contains_key(call_hash),
 			"whitelist not removed"
 		);
 		ensure!(
-			!T::PreimageProvider::preimage_requested(&call_hash),
+			!T::Preimages::is_requested(&call_hash),
 			"preimage still requested"
 		);
 	}
@@ -101,7 +98,7 @@ benchmarks! {
 		let remark = sp_std::vec![1u8; n as usize];
 
 		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark }.into();
-		let call_hash = T::Hashing::hash_of(&call);
+		let call_hash = call.blake2_256().into();
 
 		Pallet::<T>::whitelist_call(origin.clone(), call_hash)
 			.expect("whitelisting call must be successful");
@@ -112,7 +109,7 @@ benchmarks! {
 			"whitelist not removed"
 		);
 		ensure!(
-			!T::PreimageProvider::preimage_requested(&call_hash),
+			!T::Preimages::is_requested(&call_hash),
 			"preimage still requested"
 		);
 	}

substrate/frame/whitelist/src/lib.rs

@@ -27,7 +27,7 @@
 //! with the root origin.
 //!
 //! In the meantime the call corresponding to the hash must have been submitted to the pre-image
-//! handler [`PreimageProvider`].
+//! handler [`pallet::Config::Preimages`].
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
@@ -44,11 +44,12 @@ use codec::{DecodeLimit, Encode, FullCodec};
 use frame_support::{
 	dispatch::{GetDispatchInfo, PostDispatchInfo},
 	ensure,
-	traits::{PreimageProvider, PreimageRecipient},
+	traits::{Hash as PreimageHash, QueryPreimage, StorePreimage},
 	weights::Weight,
+	Hashable,
 };
 use scale_info::TypeInfo;
-use sp_runtime::traits::{Dispatchable, Hash};
+use sp_runtime::traits::Dispatchable;
 use sp_std::prelude::*;
 
 pub use pallet::*;
@@ -80,8 +81,7 @@ pub mod pallet {
 		type DispatchWhitelistedOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
 		/// The handler of pre-images.
-		// NOTE: recipient is only needed for benchmarks.
-		type PreimageProvider: PreimageProvider<Self::Hash> + PreimageRecipient<Self::Hash>;
+		type Preimages: QueryPreimage + StorePreimage;
 
 		/// The weight information for this pallet.
 		type WeightInfo: WeightInfo;
@@ -94,9 +94,9 @@ pub mod pallet {
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
-		CallWhitelisted { call_hash: T::Hash },
-		WhitelistedCallRemoved { call_hash: T::Hash },
-		WhitelistedCallDispatched { call_hash: T::Hash, result: DispatchResultWithPostInfo },
+		CallWhitelisted { call_hash: PreimageHash },
+		WhitelistedCallRemoved { call_hash: PreimageHash },
+		WhitelistedCallDispatched { call_hash: PreimageHash, result: DispatchResultWithPostInfo },
 	}
 
 	#[pallet::error]
@@ -114,12 +114,13 @@ pub mod pallet {
 	}
 
 	#[pallet::storage]
-	pub type WhitelistedCall<T: Config> = StorageMap<_, Twox64Concat, T::Hash, (), OptionQuery>;
+	pub type WhitelistedCall<T: Config> =
+		StorageMap<_, Twox64Concat, PreimageHash, (), OptionQuery>;
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		#[pallet::weight(T::WeightInfo::whitelist_call())]
-		pub fn whitelist_call(origin: OriginFor<T>, call_hash: T::Hash) -> DispatchResult {
+		pub fn whitelist_call(origin: OriginFor<T>, call_hash: PreimageHash) -> DispatchResult {
 			T::WhitelistOrigin::ensure_origin(origin)?;
 
 			ensure!(
@@ -128,7 +129,7 @@ pub mod pallet {
 			);
 
 			WhitelistedCall::<T>::insert(call_hash, ());
-			T::PreimageProvider::request_preimage(&call_hash);
+			T::Preimages::request(&call_hash);
 
 			Self::deposit_event(Event::<T>::CallWhitelisted { call_hash });
 
@@ -136,12 +137,15 @@ pub mod pallet {
 		}
 
 		#[pallet::weight(T::WeightInfo::remove_whitelisted_call())]
-		pub fn remove_whitelisted_call(origin: OriginFor<T>, call_hash: T::Hash) -> DispatchResult {
+		pub fn remove_whitelisted_call(
+			origin: OriginFor<T>,
+			call_hash: PreimageHash,
+		) -> DispatchResult {
 			T::WhitelistOrigin::ensure_origin(origin)?;
 
 			WhitelistedCall::<T>::take(call_hash).ok_or(Error::<T>::CallIsNotWhitelisted)?;
 
-			T::PreimageProvider::unrequest_preimage(&call_hash);
+			T::Preimages::unrequest(&call_hash);
 
 			Self::deposit_event(Event::<T>::WhitelistedCallRemoved { call_hash });
 
@@ -149,11 +153,13 @@ pub mod pallet {
 		}
 
 		#[pallet::weight(
-			T::WeightInfo::dispatch_whitelisted_call().saturating_add(*call_weight_witness)
+			T::WeightInfo::dispatch_whitelisted_call(*call_encoded_len)
+				.saturating_add(*call_weight_witness)
 		)]
 		pub fn dispatch_whitelisted_call(
 			origin: OriginFor<T>,
-			call_hash: T::Hash,
+			call_hash: PreimageHash,
+			call_encoded_len: u32,
 			call_weight_witness: Weight,
 		) -> DispatchResultWithPostInfo {
 			T::DispatchWhitelistedOrigin::ensure_origin(origin)?;
@@ -163,8 +169,8 @@ pub mod pallet {
 				Error::<T>::CallIsNotWhitelisted,
 			);
 
-			let call = T::PreimageProvider::get_preimage(&call_hash)
-				.ok_or(Error::<T>::UnavailablePreImage)?;
+			let call = T::Preimages::fetch(&call_hash, Some(call_encoded_len))
+				.map_err(|_| Error::<T>::UnavailablePreImage)?;
 
 			let call = <T as Config>::RuntimeCall::decode_all_with_depth_limit(
 				sp_api::MAX_EXTRINSIC_DEPTH,
@@ -177,8 +183,9 @@ pub mod pallet {
 				Error::<T>::InvalidCallWeightWitness
 			);
 
-			let actual_weight = Self::clean_and_dispatch(call_hash, call)
-				.map(|w| w.saturating_add(T::WeightInfo::dispatch_whitelisted_call()));
+			let actual_weight = Self::clean_and_dispatch(call_hash, call).map(|w| {
+				w.saturating_add(T::WeightInfo::dispatch_whitelisted_call(call_encoded_len))
+			});
 
 			Ok(actual_weight.into())
 		}
@@ -196,7 +203,7 @@ pub mod pallet {
 		) -> DispatchResultWithPostInfo {
 			T::DispatchWhitelistedOrigin::ensure_origin(origin)?;
 
-			let call_hash = <T as frame_system::Config>::Hashing::hash_of(&call);
+			let call_hash = call.blake2_256().into();
 
 			ensure!(
 				WhitelistedCall::<T>::contains_key(call_hash),
@@ -217,10 +224,13 @@ impl<T: Config> Pallet<T> {
 	/// Clean whitelisting/preimage and dispatch call.
 	///
 	/// Return the call actual weight of the dispatched call if there is some.
-	fn clean_and_dispatch(call_hash: T::Hash, call: <T as Config>::RuntimeCall) -> Option<Weight> {
+	fn clean_and_dispatch(
+		call_hash: PreimageHash,
+		call: <T as Config>::RuntimeCall,
+	) -> Option<Weight> {
 		WhitelistedCall::<T>::remove(call_hash);
 
-		T::PreimageProvider::unrequest_preimage(&call_hash);
+		T::Preimages::unrequest(&call_hash);
 
 		let result = call.dispatch(frame_system::Origin::<T>::Root.into());
 

substrate/frame/whitelist/src/mock.rs

@@ -106,7 +106,7 @@ impl pallet_whitelist::Config for Test {
 	type RuntimeCall = RuntimeCall;
 	type WhitelistOrigin = EnsureRoot<Self::AccountId>;
 	type DispatchWhitelistedOrigin = EnsureRoot<Self::AccountId>;
-	type PreimageProvider = Preimage;
+	type Preimages = Preimage;
 	type WeightInfo = ();
 }
 

substrate/frame/whitelist/src/tests.rs

@@ -20,7 +20,10 @@
 use crate::mock::*;
 use codec::Encode;
 use frame_support::{
-	assert_noop, assert_ok, dispatch::GetDispatchInfo, traits::PreimageProvider, weights::Weight,
+	assert_noop, assert_ok,
+	dispatch::GetDispatchInfo,
+	traits::{QueryPreimage, StorePreimage},
+	weights::Weight,
 };
 use sp_runtime::{traits::Hash, DispatchError};
 
@@ -43,7 +46,7 @@ fn test_whitelist_call_and_remove() {
 
 		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
 
-		assert!(Preimage::preimage_requested(&call_hash));
+		assert!(Preimage::is_requested(&call_hash));
 
 		assert_noop!(
 			Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash),
@@ -57,7 +60,7 @@ fn test_whitelist_call_and_remove() {
 
 		assert_ok!(Whitelist::remove_whitelisted_call(RuntimeOrigin::root(), call_hash));
 
-		assert!(!Preimage::preimage_requested(&call_hash));
+		assert!(!Preimage::is_requested(&call_hash));
 
 		assert_noop!(
 			Whitelist::remove_whitelisted_call(RuntimeOrigin::root(), call_hash),
@@ -72,33 +75,50 @@ fn test_whitelist_call_and_execute() {
 		let call = RuntimeCall::System(frame_system::Call::remark_with_event { remark: vec![1] });
 		let call_weight = call.get_dispatch_info().weight;
 		let encoded_call = call.encode();
+		let call_encoded_len = encoded_call.len() as u32;
 		let call_hash = <Test as frame_system::Config>::Hashing::hash(&encoded_call[..]);
 
 		assert_noop!(
-			Whitelist::dispatch_whitelisted_call(RuntimeOrigin::root(), call_hash, call_weight),
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
 			crate::Error::<Test>::CallIsNotWhitelisted,
 		);
 
 		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
 
 		assert_noop!(
-			Whitelist::dispatch_whitelisted_call(RuntimeOrigin::signed(1), call_hash, call_weight),
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::signed(1),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
 			DispatchError::BadOrigin,
 		);
 
-		assert_noop!(
-			Whitelist::dispatch_whitelisted_call(RuntimeOrigin::root(), call_hash, call_weight),
-			crate::Error::<Test>::UnavailablePreImage,
-		);
-
-		assert_ok!(Preimage::note_preimage(RuntimeOrigin::root(), encoded_call));
-
-		assert!(Preimage::preimage_requested(&call_hash));
-
 		assert_noop!(
 			Whitelist::dispatch_whitelisted_call(
 				RuntimeOrigin::root(),
 				call_hash,
+				call_encoded_len,
+				call_weight
+			),
+			crate::Error::<Test>::UnavailablePreImage,
+		);
+
+		assert_ok!(Preimage::note(encoded_call.into()));
+
+		assert!(Preimage::is_requested(&call_hash));
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
 				call_weight - Weight::from_ref_time(1)
 			),
 			crate::Error::<Test>::InvalidCallWeightWitness,
@@ -107,13 +127,19 @@ fn test_whitelist_call_and_execute() {
 		assert_ok!(Whitelist::dispatch_whitelisted_call(
 			RuntimeOrigin::root(),
 			call_hash,
+			call_encoded_len,
 			call_weight
 		));
 
-		assert!(!Preimage::preimage_requested(&call_hash));
+		assert!(!Preimage::is_requested(&call_hash));
 
 		assert_noop!(
-			Whitelist::dispatch_whitelisted_call(RuntimeOrigin::root(), call_hash, call_weight),
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
 			crate::Error::<Test>::CallIsNotWhitelisted,
 		);
 	});
@@ -124,21 +150,24 @@ fn test_whitelist_call_and_execute_failing_call() {
 	new_test_ext().execute_with(|| {
 		let call = RuntimeCall::Whitelist(crate::Call::dispatch_whitelisted_call {
 			call_hash: Default::default(),
+			call_encoded_len: Default::default(),
 			call_weight_witness: Weight::zero(),
 		});
 		let call_weight = call.get_dispatch_info().weight;
 		let encoded_call = call.encode();
+		let call_encoded_len = encoded_call.len() as u32;
 		let call_hash = <Test as frame_system::Config>::Hashing::hash(&encoded_call[..]);
 
 		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
-		assert_ok!(Preimage::note_preimage(RuntimeOrigin::root(), encoded_call));
-		assert!(Preimage::preimage_requested(&call_hash));
+		assert_ok!(Preimage::note(encoded_call.into()));
+		assert!(Preimage::is_requested(&call_hash));
 		assert_ok!(Whitelist::dispatch_whitelisted_call(
 			RuntimeOrigin::root(),
 			call_hash,
+			call_encoded_len,
 			call_weight
 		));
-		assert!(!Preimage::preimage_requested(&call_hash));
+		assert!(!Preimage::is_requested(&call_hash));
 	});
 }
 
@@ -151,14 +180,14 @@ fn test_whitelist_call_and_execute_without_note_preimage() {
 		let call_hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
 
 		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
-		assert!(Preimage::preimage_requested(&call_hash));
+		assert!(Preimage::is_requested(&call_hash));
 
 		assert_ok!(Whitelist::dispatch_whitelisted_call_with_preimage(
 			RuntimeOrigin::root(),
 			call.clone()
 		));
 
-		assert!(!Preimage::preimage_requested(&call_hash));
+		assert!(!Preimage::is_requested(&call_hash));
 
 		assert_noop!(
 			Whitelist::dispatch_whitelisted_call_with_preimage(RuntimeOrigin::root(), call),
@@ -176,14 +205,20 @@ fn test_whitelist_call_and_execute_decode_consumes_all() {
 		// Appending something does not make the encoded call invalid.
 		// This tests that the decode function consumes all data.
 		call.extend(call.clone());
+		let call_encoded_len = call.len() as u32;
 
 		let call_hash = <Test as frame_system::Config>::Hashing::hash(&call[..]);
 
-		assert_ok!(Preimage::note_preimage(RuntimeOrigin::root(), call));
+		assert_ok!(Preimage::note(call.into()));
 		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
 
 		assert_noop!(
-			Whitelist::dispatch_whitelisted_call(RuntimeOrigin::root(), call_hash, call_weight),
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
 			crate::Error::<Test>::UndecodableCall,
 		);
 	});

substrate/frame/whitelist/src/weights.rs

@@ -18,24 +18,25 @@
 //! Autogenerated weights for pallet_whitelist
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-11-07, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
-//! HOSTNAME: `bm2`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
+//! DATE: 2022-12-05, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
 
 // Executed Command:
-// ./target/production/substrate
+// /home/benchbot/cargo_target_dir/production/substrate
 // benchmark
 // pallet
-// --chain=dev
 // --steps=50
 // --repeat=20
-// --pallet=pallet_whitelist
 // --extrinsic=*
 // --execution=wasm
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --output=./frame/whitelist/src/weights.rs
+// --json-file=/var/lib/gitlab-runner/builds/zyw4fam_/0/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_whitelist
+// --chain=dev
 // --header=./HEADER-APACHE2
+// --output=./frame/whitelist/src/weights.rs
 // --template=./.maintain/frame-weight-template.hbs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
@@ -49,7 +50,7 @@ use sp_std::marker::PhantomData;
 pub trait WeightInfo {
 	fn whitelist_call() -> Weight;
 	fn remove_whitelisted_call() -> Weight;
-	fn dispatch_whitelisted_call() -> Weight;
+	fn dispatch_whitelisted_call(n: u32, ) -> Weight;
 	fn dispatch_whitelisted_call_with_preimage(n: u32, ) -> Weight;
 }
 
@@ -59,38 +60,41 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
 	// Storage: Preimage StatusFor (r:1 w:1)
 	fn whitelist_call() -> Weight {
-		// Minimum execution time: 26_352 nanoseconds.
-		Weight::from_ref_time(26_727_000 as u64)
-			.saturating_add(T::DbWeight::get().reads(2 as u64))
-			.saturating_add(T::DbWeight::get().writes(2 as u64))
+		// Minimum execution time: 26_261 nanoseconds.
+		Weight::from_ref_time(26_842_000)
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
 	}
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
 	// Storage: Preimage StatusFor (r:1 w:1)
 	fn remove_whitelisted_call() -> Weight {
-		// Minimum execution time: 25_536 nanoseconds.
-		Weight::from_ref_time(25_969_000 as u64)
-			.saturating_add(T::DbWeight::get().reads(2 as u64))
-			.saturating_add(T::DbWeight::get().writes(2 as u64))
+		// Minimum execution time: 25_092 nanoseconds.
+		Weight::from_ref_time(25_903_000)
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
 	}
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
-	// Storage: Preimage StatusFor (r:1 w:1)
 	// Storage: Preimage PreimageFor (r:1 w:1)
-	fn dispatch_whitelisted_call() -> Weight {
-		// Minimum execution time: 4_802_466 nanoseconds.
-		Weight::from_ref_time(4_820_197_000 as u64)
-			.saturating_add(T::DbWeight::get().reads(3 as u64))
-			.saturating_add(T::DbWeight::get().writes(3 as u64))
+	// Storage: Preimage StatusFor (r:1 w:1)
+	/// The range of component `n` is `[1, 4194294]`.
+	fn dispatch_whitelisted_call(n: u32, ) -> Weight {
+		// Minimum execution time: 36_685 nanoseconds.
+		Weight::from_ref_time(37_167_000)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(1_144).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
 	}
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
 	// Storage: Preimage StatusFor (r:1 w:1)
 	/// The range of component `n` is `[1, 10000]`.
 	fn dispatch_whitelisted_call_with_preimage(n: u32, ) -> Weight {
-		// Minimum execution time: 29_184 nanoseconds.
-		Weight::from_ref_time(30_530_970 as u64)
-			// Standard Error: 7
-			.saturating_add(Weight::from_ref_time(1_496 as u64).saturating_mul(n as u64))
-			.saturating_add(T::DbWeight::get().reads(2 as u64))
-			.saturating_add(T::DbWeight::get().writes(2 as u64))
+		// Minimum execution time: 29_187 nanoseconds.
+		Weight::from_ref_time(29_896_714)
+			// Standard Error: 6
+			.saturating_add(Weight::from_ref_time(1_505).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
 	}
 }
 
@@ -99,37 +103,40 @@ impl WeightInfo for () {
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
 	// Storage: Preimage StatusFor (r:1 w:1)
 	fn whitelist_call() -> Weight {
-		// Minimum execution time: 26_352 nanoseconds.
-		Weight::from_ref_time(26_727_000 as u64)
-			.saturating_add(RocksDbWeight::get().reads(2 as u64))
-			.saturating_add(RocksDbWeight::get().writes(2 as u64))
+		// Minimum execution time: 26_261 nanoseconds.
+		Weight::from_ref_time(26_842_000)
+			.saturating_add(RocksDbWeight::get().reads(2))
+			.saturating_add(RocksDbWeight::get().writes(2))
 	}
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
 	// Storage: Preimage StatusFor (r:1 w:1)
 	fn remove_whitelisted_call() -> Weight {
-		// Minimum execution time: 25_536 nanoseconds.
-		Weight::from_ref_time(25_969_000 as u64)
-			.saturating_add(RocksDbWeight::get().reads(2 as u64))
-			.saturating_add(RocksDbWeight::get().writes(2 as u64))
+		// Minimum execution time: 25_092 nanoseconds.
+		Weight::from_ref_time(25_903_000)
+			.saturating_add(RocksDbWeight::get().reads(2))
+			.saturating_add(RocksDbWeight::get().writes(2))
 	}
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
-	// Storage: Preimage StatusFor (r:1 w:1)
 	// Storage: Preimage PreimageFor (r:1 w:1)
-	fn dispatch_whitelisted_call() -> Weight {
-		// Minimum execution time: 4_802_466 nanoseconds.
-		Weight::from_ref_time(4_820_197_000 as u64)
-			.saturating_add(RocksDbWeight::get().reads(3 as u64))
-			.saturating_add(RocksDbWeight::get().writes(3 as u64))
+	// Storage: Preimage StatusFor (r:1 w:1)
+	/// The range of component `n` is `[1, 4194294]`.
+	fn dispatch_whitelisted_call(n: u32, ) -> Weight {
+		// Minimum execution time: 36_685 nanoseconds.
+		Weight::from_ref_time(37_167_000)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(1_144).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(3))
+			.saturating_add(RocksDbWeight::get().writes(3))
 	}
 	// Storage: Whitelist WhitelistedCall (r:1 w:1)
 	// Storage: Preimage StatusFor (r:1 w:1)
 	/// The range of component `n` is `[1, 10000]`.
 	fn dispatch_whitelisted_call_with_preimage(n: u32, ) -> Weight {
-		// Minimum execution time: 29_184 nanoseconds.
-		Weight::from_ref_time(30_530_970 as u64)
-			// Standard Error: 7
-			.saturating_add(Weight::from_ref_time(1_496 as u64).saturating_mul(n as u64))
-			.saturating_add(RocksDbWeight::get().reads(2 as u64))
-			.saturating_add(RocksDbWeight::get().writes(2 as u64))
+		// Minimum execution time: 29_187 nanoseconds.
+		Weight::from_ref_time(29_896_714)
+			// Standard Error: 6
+			.saturating_add(Weight::from_ref_time(1_505).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(2))
+			.saturating_add(RocksDbWeight::get().writes(2))
 	}
 }