git.delta.rocks / unique-network / refs/commits / cbfc871bee98

--- a/Makefile
+++ b/Makefile
@@ -127,16 +127,16 @@
 
 .PHONY: bench-foreign-assets
 bench-foreign-assets:
-	make _bench PALLET=foreign-assets	
+	make _bench PALLET=foreign-assets
+
+.PHONY: bench-collator-selection
+bench-collator-selection:
+	make _bench PALLET=collator-selection
 
 .PHONY: bench-app-promotion
 bench-app-promotion:
 	make _bench PALLET=app-promotion PALLET_DIR=app-promotion
 	
 .PHONY: bench
-<<<<<<< HEAD
-bench: bench-data-management bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-scheduler bench-rmrk-core bench-rmrk-equip bench-foreign-assets
-=======
 # Disabled: bench-scheduler, bench-rmrk-core, bench-rmrk-equip
-bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-foreign-assets
->>>>>>> develop
+bench: bench-data-management bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-foreign-assets

--- a/pallets/collator-selection/src/benchmarking.rs
+++ b/pallets/collator-selection/src/benchmarking.rs
@@ -45,10 +45,15 @@
 use frame_system::{EventRecord, RawOrigin};
 use pallet_authorship::EventHandler;
 use pallet_session::{self as session, SessionManager};
+use pallet_configuration::{
+	self as configuration, BalanceOf,
+	CollatorSelectionDesiredCollatorsOverride as DesiredCollators,
+	CollatorSelectionLicenseBondOverride as LicenseBond,
+};
 use sp_std::prelude::*;
 
-pub type BalanceOf<T> =
-	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+/*pub type BalanceOf<T> =
+<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;*/
 
 const SEED: u32 = 0;
 
@@ -111,7 +116,7 @@
 	validators.into_iter().map(|(who, _)| who).collect()
 }
 
-fn register_candidates<T: Config>(count: u32) {
+fn register_candidates<T: Config + configuration::Config>(count: u32) {
 	let candidates = (0..count)
 		.map(|c| account("candidate", c, SEED))
 		.collect::<Vec<_>>();
@@ -122,27 +127,44 @@
 
 	for who in candidates {
 		T::Currency::make_free_balance_be(&who, <LicenseBond<T>>::get() * 2u32.into());
-		<CollatorSelection<T>>::register_as_candidate(RawOrigin::Signed(who).into()).unwrap();
+		<CollatorSelection<T>>::get_license(RawOrigin::Signed(who.clone()).into()).unwrap();
+		<CollatorSelection<T>>::onboard(RawOrigin::Signed(who).into()).unwrap();
 	}
 }
 
 benchmarks! {
-	where_clause { where T: pallet_authorship::Config + session::Config }
+	where_clause { where T: pallet_authorship::Config + session::Config + configuration::Config }
+
+	add_invulnerable {
+		let b in 1 .. T::MaxCollators::get();
+		let new_invulnerable = register_validators::<T>(b)[0].clone();
+		let origin = T::UpdateOrigin::successful_origin();
+	}: {
+		assert_ok!(
+			<CollatorSelection<T>>::add_invulnerable(origin, new_invulnerable.clone())
+		);
+	}
+	verify {
+		assert_last_event::<T>(Event::InvulnerableAdded{invulnerable: new_invulnerable}.into());
+	}
 
-	set_invulnerables {
+	remove_invulnerable {
 		let b in 1 .. T::MaxCollators::get();
-		let new_invulnerables = register_validators::<T>(b);
+		let new_invulnerable = register_validators::<T>(b)[0].clone();
 		let origin = T::UpdateOrigin::successful_origin();
+		assert_ok!(
+			<CollatorSelection<T>>::add_invulnerable(origin.clone(), new_invulnerable.clone())
+		);
 	}: {
 		assert_ok!(
-			<CollatorSelection<T>>::set_invulnerables(origin, new_invulnerables.clone())
+			<CollatorSelection<T>>::remove_invulnerable(origin, new_invulnerable.clone())
 		);
 	}
 	verify {
-		assert_last_event::<T>(Event::NewInvulnerables{invulnerables: new_invulnerables}.into());
+		assert_last_event::<T>(Event::InvulnerableRemoved{invulnerable: new_invulnerable}.into());
 	}
 
-	set_desired_collators {
+	/*set_desired_collators {
 		let max: u32 = 999;
 		let origin = T::UpdateOrigin::successful_origin();
 	}: {
@@ -164,11 +186,9 @@
 	}
 	verify {
 		assert_last_event::<T>(Event::NewLicenseBond{bond_amount}.into());
-	}
+	}*/
 
-	// worse case is when we have all the max-candidate slots filled except one, and we fill that
-	// one.
-	register_as_candidate {
+	get_license {
 		let c in 1 .. T::MaxCollators::get();
 
 		<LicenseBond<T>>::put(T::Currency::minimum_balance());
@@ -189,27 +209,96 @@
 
 	}: _(RawOrigin::Signed(caller.clone()))
 	verify {
-		assert_last_event::<T>(Event::CandidateAdded{account_id: caller, deposit: bond / 2u32.into()}.into());
+		assert_last_event::<T>(Event::LicenseObtained{account_id: caller, deposit: bond / 2u32.into()}.into());
 	}
 
-	// worse case is the last candidate leaving.
-	leave_intent {
-		let c in (T::MinCandidates::get() + 1) .. T::MaxCollators::get();
+	// worst case is when we have all the max-candidate slots filled except one, and we fill that
+	// one.
+	onboard {
+		let c in 1 .. T::MaxCollators::get();
+
 		<LicenseBond<T>>::put(T::Currency::minimum_balance());
+		<DesiredCollators<T>>::put(c + 1);
+
+		register_validators::<T>(c);
+		register_candidates::<T>(c);
+
+		let caller: T::AccountId = whitelisted_caller();
+		let bond: BalanceOf<T> = T::Currency::minimum_balance() * 2u32.into();
+		T::Currency::make_free_balance_be(&caller, bond.clone());
+
+		let origin = RawOrigin::Signed(caller.clone());
+
+		<session::Pallet<T>>::set_keys(
+			origin.clone().into(),
+			keys::<T>(c + 1),
+			Vec::new()
+		).unwrap();
+
+		assert_ok!(
+			<CollatorSelection<T>>::get_license(origin.clone().into())
+		);
+	}: _(origin)
+	verify {
+		assert_last_event::<T>(Event::CandidateAdded{account_id: caller}.into());
+	}
+
+	// worst case is the last candidate leaving.
+	offboard {
+		let c in 1 .. T::MaxCollators::get();
+		<LicenseBond<T>>::put(T::Currency::minimum_balance());
 		<DesiredCollators<T>>::put(c);
 
 		register_validators::<T>(c);
 		register_candidates::<T>(c);
 
-		let leaving = <Candidates<T>>::get().last().unwrap().who.clone();
+		let leaving = <Candidates<T>>::get().last().unwrap().clone();
 		whitelist!(leaving);
 	}: _(RawOrigin::Signed(leaving.clone()))
 	verify {
-		// todo:collator verify these
-		assert_last_event::<T>(Event::CandidateRemoved{account_id: leaving, deposit_returned: bond / 2u32.into() }.into());
+		assert_last_event::<T>(Event::CandidateRemoved{account_id: leaving}.into());
 	}
 
-	// worse case is paying a non-existing candidate account.
+	// worst case is the last candidate leaving.
+	release_license {
+		let c in 1 .. T::MaxCollators::get();
+		let bond = T::Currency::minimum_balance();
+		<LicenseBond<T>>::put(bond);
+		<DesiredCollators<T>>::put(c);
+
+		register_validators::<T>(c);
+		register_candidates::<T>(c);
+
+		let leaving = <Candidates<T>>::get().last().unwrap().clone();
+		whitelist!(leaving);
+	}: _(RawOrigin::Signed(leaving.clone()))
+	verify {
+		assert_last_event::<T>(Event::LicenseReleased{account_id: leaving, deposit_returned: bond}.into());
+	}
+
+	// worst case is the last candidate leaving.
+	force_release_license {
+		let c in 1 .. T::MaxCollators::get();
+		let bond = T::Currency::minimum_balance();
+		<LicenseBond<T>>::put(bond);
+		<DesiredCollators<T>>::put(c);
+
+		register_validators::<T>(c);
+		register_candidates::<T>(c);
+
+		let leaving = <Candidates<T>>::get().last().unwrap().clone();
+		whitelist!(leaving);
+		let origin = T::UpdateOrigin::successful_origin();
+	}: {
+		assert_ok!(
+			<CollatorSelection<T>>::force_release_license(origin, leaving.clone())
+		);
+	}
+	verify {
+		assert_last_event::<T>(Event::LicenseReleased{account_id: leaving, deposit_returned: bond}.into());
+	}
+
+	// worst case is paying a non-existing candidate account.
 	note_author {
 		<LicenseBond<T>>::put(T::Currency::minimum_balance());
 		T::Currency::make_free_balance_be(
@@ -247,16 +336,16 @@
 		let non_removals = c.saturating_sub(r);
 
 		for i in 0..c {
-			<LastAuthoredBlock<T>>::insert(candidates[i as usize].who.clone(), zero_block);
+			<LastAuthoredBlock<T>>::insert(candidates[i as usize].clone(), zero_block);
 		}
 
 		if non_removals > 0 {
 			for i in 0..non_removals {
-				<LastAuthoredBlock<T>>::insert(candidates[i as usize].who.clone(), new_block);
+				<LastAuthoredBlock<T>>::insert(candidates[i as usize].clone(), new_block);
 			}
 		} else {
 			for i in 0..c {
-				<LastAuthoredBlock<T>>::insert(candidates[i as usize].who.clone(), new_block);
+				<LastAuthoredBlock<T>>::insert(candidates[i as usize].clone(), new_block);
 			}
 		}
 
@@ -268,10 +357,8 @@
 	}: {
 		<CollatorSelection<T> as SessionManager<_>>::new_session(0)
 	} verify {
-		if c > r && non_removals >= T::MinCandidates::get() {
+		if c > r {
 			assert!(<Candidates<T>>::get().len() < pre_length);
-		} else if c > r && non_removals < T::MinCandidates::get() {
-			assert!(<Candidates<T>>::get().len() == T::MinCandidates::get() as usize);
 		} else {
 			assert!(<Candidates<T>>::get().len() == pre_length);
 		}

--- a/pallets/collator-selection/src/lib.rs
+++ b/pallets/collator-selection/src/lib.rs
@@ -235,7 +235,7 @@
 			account_id: T::AccountId,
 			deposit: BalanceOf<T>,
 		},
-		LicenseForfeited {
+		LicenseReleased {
 			account_id: T::AccountId,
 			deposit_returned: BalanceOf<T>,
 		},
@@ -285,7 +285,7 @@
 	impl<T: Config> Pallet<T> {
 		/// Add a collator to the list of invulnerable (fixed) collators.
 		#[pallet::call_index(0)]
-		#[pallet::weight(T::WeightInfo::set_invulnerables(1u32))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::add_invulnerable(T::MaxCollators::get()))] // todo:collator weight
 		pub fn add_invulnerable(
 			origin: OriginFor<T>,
 			new: T::AccountId,
@@ -315,7 +315,7 @@
 
 		/// Remove a collator from the list of invulnerable (fixed) collators.
 		#[pallet::call_index(1)]
-		#[pallet::weight(T::WeightInfo::set_invulnerables(1))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::remove_invulnerable(T::MaxCollators::get()))] // todo:collator weight
 		pub fn remove_invulnerable(
 			origin: OriginFor<T>,
 			who: T::AccountId,
@@ -344,7 +344,7 @@
 		///
 		/// This call is not available to `Invulnerable` collators.
 		#[pallet::call_index(2)]
-		#[pallet::weight(T::WeightInfo::register_as_candidate(T::MaxCollators::get()))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::get_license(T::MaxCollators::get()))] // todo:collator weight
 		pub fn get_license(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			// register_as_candidate
 			let who = ensure_signed(origin)?;
@@ -377,7 +377,7 @@
 		///
 		/// This call is not available to `Invulnerable` collators.
 		#[pallet::call_index(3)]
-		#[pallet::weight(T::WeightInfo::register_as_candidate(T::MaxCollators::get()))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::onboard(T::MaxCollators::get()))] // todo:collator weight
 		pub fn onboard(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			// register_as_candidate
 			let who = ensure_signed(origin)?;
@@ -417,33 +417,33 @@
 				})?;
 
 			Self::deposit_event(Event::CandidateAdded { account_id: who });
-			Ok(Some(T::WeightInfo::register_as_candidate(current_count as u32)).into())
+			Ok(Some(T::WeightInfo::onboard(current_count as u32)).into())
 		}
 
 		/// Deregister `origin` as a collator candidate. Note that the collator can only leave on
 		/// session change. The license to `onboard` later at any other time will remain.
 		#[pallet::call_index(4)]
-		#[pallet::weight(T::WeightInfo::leave_intent(T::MaxCollators::get()))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::offboard(T::MaxCollators::get()))] // todo:collator weight
 		pub fn offboard(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			// leave_intent
 			let who = ensure_signed(origin)?;
 			let current_count = Self::try_remove_candidate(&who)?;
 
-			Ok(Some(T::WeightInfo::leave_intent(current_count as u32)).into()) // todo:collator weight
+			Ok(Some(T::WeightInfo::offboard(current_count as u32)).into()) // todo:collator weight
 		}
 
 		/// Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.
 		///
 		/// This call is not available to `Invulnerable` collators.
 		#[pallet::call_index(5)]
-		#[pallet::weight(T::WeightInfo::leave_intent(T::MaxCollators::get()))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::release_license(T::MaxCollators::get()))] // todo:collator weight
 		pub fn release_license(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
 			// leave_intent
 			let who = ensure_signed(origin)?;
 
 			let current_count = Self::try_remove_candidate_and_release_license(&who, false, true)?;
 
-			Ok(Some(T::WeightInfo::leave_intent(current_count as u32)).into()) // todo:collator weight
+			Ok(Some(T::WeightInfo::release_license(current_count as u32)).into()) // todo:collator weight
 		}
 
 		/// Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.
@@ -452,7 +452,7 @@
 		///
 		/// This call is, of course, not applicable to `Invulnerable` collators.
 		#[pallet::call_index(6)]
-		#[pallet::weight(T::WeightInfo::leave_intent(T::MaxCollators::get()))] // todo:collator weight
+		#[pallet::weight(T::WeightInfo::force_release_license(T::MaxCollators::get()))] // todo:collator weight
 		pub fn force_release_license(
 			origin: OriginFor<T>,
 			who: T::AccountId,
@@ -462,7 +462,7 @@
 
 			let current_count = Self::try_remove_candidate_and_release_license(&who, false, true)?;
 
-			Ok(Some(T::WeightInfo::leave_intent(current_count as u32)).into()) // todo:collator weight
+			Ok(Some(T::WeightInfo::force_release_license(current_count as u32)).into()) // todo:collator weight
 		}
 	}
 
@@ -534,7 +534,7 @@
 					Err(Error::<T>::NoLicense.into())
 				}
 			})?;
-			Self::deposit_event(Event::LicenseForfeited {
+			Self::deposit_event(Event::LicenseReleased {
 				account_id: who.clone(),
 				deposit_returned,
 			});

--- a/pallets/collator-selection/src/weights.rs
+++ b/pallets/collator-selection/src/weights.rs
@@ -44,11 +44,13 @@
 // todo:collator re-generate weights
 // The weight info trait for `pallet_collator_selection`.
 pub trait WeightInfo {
-	fn set_invulnerables(_b: u32) -> Weight;
-	fn set_desired_collators() -> Weight;
-	fn set_license_bond() -> Weight;
-	fn register_as_candidate(_c: u32) -> Weight;
-	fn leave_intent(_c: u32) -> Weight;
+	fn add_invulnerable(_b: u32) -> Weight;
+	fn remove_invulnerable(_b: u32) -> Weight;
+	fn get_license(_c: u32) -> Weight;
+	fn onboard(_c: u32) -> Weight;
+	fn offboard(_c: u32) -> Weight;
+	fn release_license(_c: u32) -> Weight;
+	fn force_release_license(_c: u32) -> Weight;
 	fn note_author() -> Weight;
 	fn new_session(_c: u32, _r: u32) -> Weight;
 }
@@ -56,26 +58,47 @@
 /// Weights for pallet_collator_selection using the Substrate node and recommended hardware.
 pub struct SubstrateWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-	fn set_invulnerables(b: u32) -> Weight {
+	fn add_invulnerable(b: u32) -> Weight {
 		Weight::from_ref_time(18_563_000 as u64)
 			// Standard Error: 0
 			.saturating_add(Weight::from_ref_time(68_000 as u64).saturating_mul(b as u64))
 			.saturating_add(T::DbWeight::get().writes(1 as u64))
 	}
-	fn set_desired_collators() -> Weight {
-		Weight::from_ref_time(16_363_000 as u64).saturating_add(T::DbWeight::get().writes(1 as u64))
+	fn remove_invulnerable(b: u32) -> Weight {
+		Weight::from_ref_time(18_563_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(68_000 as u64).saturating_mul(b as u64))
+			.saturating_add(T::DbWeight::get().writes(1 as u64))
 	}
-	fn set_license_bond() -> Weight {
-		Weight::from_ref_time(16_840_000 as u64).saturating_add(T::DbWeight::get().writes(1 as u64))
+	fn get_license(c: u32) -> Weight {
+		Weight::from_ref_time(71_196_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(198_000 as u64).saturating_mul(c as u64))
+			.saturating_add(T::DbWeight::get().reads(4 as u64))
+			.saturating_add(T::DbWeight::get().writes(2 as u64))
 	}
-	fn register_as_candidate(c: u32) -> Weight {
+	fn onboard(c: u32) -> Weight {
 		Weight::from_ref_time(71_196_000 as u64)
 			// Standard Error: 0
 			.saturating_add(Weight::from_ref_time(198_000 as u64).saturating_mul(c as u64))
 			.saturating_add(T::DbWeight::get().reads(4 as u64))
 			.saturating_add(T::DbWeight::get().writes(2 as u64))
 	}
-	fn leave_intent(c: u32) -> Weight {
+	fn offboard(c: u32) -> Weight {
+		Weight::from_ref_time(55_336_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(151_000 as u64).saturating_mul(c as u64))
+			.saturating_add(T::DbWeight::get().reads(1 as u64))
+			.saturating_add(T::DbWeight::get().writes(2 as u64))
+	}
+	fn release_license(c: u32) -> Weight {
+		Weight::from_ref_time(55_336_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(151_000 as u64).saturating_mul(c as u64))
+			.saturating_add(T::DbWeight::get().reads(1 as u64))
+			.saturating_add(T::DbWeight::get().writes(2 as u64))
+	}
+	fn force_release_license(c: u32) -> Weight {
 		Weight::from_ref_time(55_336_000 as u64)
 			// Standard Error: 0
 			.saturating_add(Weight::from_ref_time(151_000 as u64).saturating_mul(c as u64))
@@ -102,28 +125,47 @@
 
 // For backwards compatibility and tests
 impl WeightInfo for () {
-	fn set_invulnerables(b: u32) -> Weight {
+	fn add_invulnerable(b: u32) -> Weight {
 		Weight::from_ref_time(18_563_000 as u64)
 			// Standard Error: 0
 			.saturating_add(Weight::from_ref_time(68_000 as u64).saturating_mul(b as u64))
 			.saturating_add(RocksDbWeight::get().writes(1 as u64))
 	}
-	fn set_desired_collators() -> Weight {
-		Weight::from_ref_time(16_363_000 as u64)
+	fn remove_invulnerable(b: u32) -> Weight {
+		Weight::from_ref_time(18_563_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(68_000 as u64).saturating_mul(b as u64))
 			.saturating_add(RocksDbWeight::get().writes(1 as u64))
 	}
-	fn set_license_bond() -> Weight {
-		Weight::from_ref_time(16_840_000 as u64)
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
+	fn get_license(c: u32) -> Weight {
+		Weight::from_ref_time(71_196_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(198_000 as u64).saturating_mul(c as u64))
+			.saturating_add(RocksDbWeight::get().reads(4 as u64))
+			.saturating_add(RocksDbWeight::get().writes(2 as u64))
 	}
-	fn register_as_candidate(c: u32) -> Weight {
+	fn onboard(c: u32) -> Weight {
 		Weight::from_ref_time(71_196_000 as u64)
 			// Standard Error: 0
 			.saturating_add(Weight::from_ref_time(198_000 as u64).saturating_mul(c as u64))
 			.saturating_add(RocksDbWeight::get().reads(4 as u64))
 			.saturating_add(RocksDbWeight::get().writes(2 as u64))
 	}
-	fn leave_intent(c: u32) -> Weight {
+	fn offboard(c: u32) -> Weight {
+		Weight::from_ref_time(55_336_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(151_000 as u64).saturating_mul(c as u64))
+			.saturating_add(RocksDbWeight::get().reads(1 as u64))
+			.saturating_add(RocksDbWeight::get().writes(2 as u64))
+	}
+	fn release_license(c: u32) -> Weight {
+		Weight::from_ref_time(55_336_000 as u64)
+			// Standard Error: 0
+			.saturating_add(Weight::from_ref_time(151_000 as u64).saturating_mul(c as u64))
+			.saturating_add(RocksDbWeight::get().reads(1 as u64))
+			.saturating_add(RocksDbWeight::get().writes(2 as u64))
+	}
+	fn force_release_license(c: u32) -> Weight {
 		Weight::from_ref_time(55_336_000 as u64)
 			// Standard Error: 0
 			.saturating_add(Weight::from_ref_time(151_000 as u64).saturating_mul(c as u64))

--- a/pallets/data-management/src/benchmarking.rs
+++ b/pallets/data-management/src/benchmarking.rs
@@ -63,4 +63,28 @@
 		use codec::Encode;
 		let logs = (0..b).map(|_| <T as Config>::RuntimeEvent::from(crate::Event::<T>::TestEvent).encode()).collect::<Vec<_>>();
 	}: _(RawOrigin::Root, logs)
+
+	set_identities {
+		let b in 0..600;
+		use frame_benchmarking::account;
+		use pallet_identity::{BalanceOf, Registration, IdentityInfo};
+		let identities = (0..b).map(|i| (
+			account("caller", i, 0),
+			Some(Registration::<BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields> {
+				judgements: Default::default(),
+				deposit: Default::default(),
+				info: IdentityInfo {
+					additional: Default::default(),
+					display: Default::default(),
+					legal: Default::default(),
+					web: Default::default(),
+					riot: Default::default(),
+					email: Default::default(),
+					pgp_fingerprint: None,
+					image: Default::default(),
+					twitter: Default::default(),
+				},
+			}),
+		)).collect::<Vec<_>>();
+	}: _(RawOrigin::Root, identities)
 }

--- a/pallets/data-management/src/lib.rs
+++ b/pallets/data-management/src/lib.rs
@@ -153,12 +153,18 @@
 
 		/// Insert or remove identities.
 		#[pallet::call_index(5)]
-		#[pallet::weight(<SelfWeightOf<T>>::insert_events(identities.len() as u32))] // todo:collator weight
+		#[pallet::weight(<SelfWeightOf<T>>::set_identities(identities.len() as u32))] // todo:collator weight
 		pub fn set_identities(
 			origin: OriginFor<T>,
 			identities: Vec<(
 				T::AccountId,
-				Option<Registration<pallet_identity::BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields>>,
+				Option<
+					Registration<
+						pallet_identity::BalanceOf<T>,
+						T::MaxRegistrars,
+						T::MaxAdditionalFields,
+					>,
+				>,
 			)>,
 		) -> DispatchResult {
 			ensure_root(origin)?;

--- a/pallets/data-management/src/weights.rs
+++ b/pallets/data-management/src/weights.rs
@@ -39,6 +39,7 @@
 	fn finish(b: u32, ) -> Weight;
 	fn insert_eth_logs(b: u32, ) -> Weight;
 	fn insert_events(b: u32, ) -> Weight;
+	fn set_identities(b: u32, ) -> Weight;
 }
 
 /// Weights for pallet_data_management using the Substrate node and recommended hardware.
@@ -80,6 +81,11 @@
 			// Standard Error: 1_227
 			.saturating_add(Weight::from_ref_time(1_311_481 as u64).saturating_mul(b as u64))
 	}
+	fn set_identities(b: u32, ) -> Weight {
+		Weight::from_ref_time(10_936_376 as u64)
+			// Standard Error: 1_227
+			.saturating_add(Weight::from_ref_time(1_311_481 as u64).saturating_mul(b as u64))
+	}
 }
 
 // For backwards compatibility and tests
@@ -120,4 +126,9 @@
 			// Standard Error: 1_227
 			.saturating_add(Weight::from_ref_time(1_311_481 as u64).saturating_mul(b as u64))
 	}
+	fn set_identities(b: u32, ) -> Weight {
+		Weight::from_ref_time(10_936_376 as u64)
+			// Standard Error: 1_227
+			.saturating_add(Weight::from_ref_time(1_311_481 as u64).saturating_mul(b as u64))
+	}
 }

--- a/pallets/identity/src/benchmarking.rs
+++ b/pallets/identity/src/benchmarking.rs
@@ -62,14 +62,16 @@
 		let registrar_origin = T::RegistrarOrigin::successful_origin();
 		Identity::<T>::add_registrar(registrar_origin, registrar_lookup)?;
 		Identity::<T>::set_fee(RawOrigin::Signed(registrar.clone()).into(), i, 10u32.into())?;
-		let fields =
-			IdentityFields(
-				IdentityField::Display |
-					IdentityField::Legal | IdentityField::Web |
-					IdentityField::Riot | IdentityField::Email |
-					IdentityField::PgpFingerprint |
-					IdentityField::Image | IdentityField::Twitter,
-			);
+		let fields = IdentityFields(
+			IdentityField::Display
+				| IdentityField::Legal
+				| IdentityField::Web
+				| IdentityField::Riot
+				| IdentityField::Email
+				| IdentityField::PgpFingerprint
+				| IdentityField::Image
+				| IdentityField::Twitter,
+		);
 		Identity::<T>::set_fields(RawOrigin::Signed(registrar.clone()).into(), i, fields)?;
 	}
 
@@ -122,7 +124,9 @@
 	let data = Data::Raw(vec![0; 32].try_into().unwrap());
 
 	IdentityInfo {
-		additional: vec![(data.clone(), data.clone()); num_fields as usize].try_into().unwrap(),
+		additional: vec![(data.clone(), data.clone()); num_fields as usize]
+			.try_into()
+			.unwrap(),
 		display: data.clone(),
 		legal: data.clone(),
 		web: data.clone(),

--- a/pallets/identity/src/lib.rs
+++ b/pallets/identity/src/lib.rs
@@ -265,24 +265,51 @@
 		/// A name was set or reset (which will remove all judgements).
 		IdentitySet { who: T::AccountId },
 		/// A name was cleared, and the given balance returned.
-		IdentityCleared { who: T::AccountId, deposit: BalanceOf<T> },
+		IdentityCleared {
+			who: T::AccountId,
+			deposit: BalanceOf<T>,
+		},
 		/// A name was removed and the given balance slashed.
-		IdentityKilled { who: T::AccountId, deposit: BalanceOf<T> },
+		IdentityKilled {
+			who: T::AccountId,
+			deposit: BalanceOf<T>,
+		},
 		/// A judgement was asked from a registrar.
-		JudgementRequested { who: T::AccountId, registrar_index: RegistrarIndex },
+		JudgementRequested {
+			who: T::AccountId,
+			registrar_index: RegistrarIndex,
+		},
 		/// A judgement request was retracted.
-		JudgementUnrequested { who: T::AccountId, registrar_index: RegistrarIndex },
+		JudgementUnrequested {
+			who: T::AccountId,
+			registrar_index: RegistrarIndex,
+		},
 		/// A judgement was given by a registrar.
-		JudgementGiven { target: T::AccountId, registrar_index: RegistrarIndex },
+		JudgementGiven {
+			target: T::AccountId,
+			registrar_index: RegistrarIndex,
+		},
 		/// A registrar was added.
 		RegistrarAdded { registrar_index: RegistrarIndex },
 		/// A sub-identity was added to an identity and the deposit paid.
-		SubIdentityAdded { sub: T::AccountId, main: T::AccountId, deposit: BalanceOf<T> },
+		SubIdentityAdded {
+			sub: T::AccountId,
+			main: T::AccountId,
+			deposit: BalanceOf<T>,
+		},
 		/// A sub-identity was removed from an identity and the deposit freed.
-		SubIdentityRemoved { sub: T::AccountId, main: T::AccountId, deposit: BalanceOf<T> },
+		SubIdentityRemoved {
+			sub: T::AccountId,
+			main: T::AccountId,
+			deposit: BalanceOf<T>,
+		},
 		/// A sub-identity was cleared, and the given deposit repatriated from the
 		/// main identity account to the sub-identity account.
-		SubIdentityRevoked { sub: T::AccountId, main: T::AccountId, deposit: BalanceOf<T> },
+		SubIdentityRevoked {
+			sub: T::AccountId,
+			main: T::AccountId,
+			deposit: BalanceOf<T>,
+		},
 	}
 
 	#[pallet::call]
@@ -358,7 +385,10 @@
 		) -> DispatchResultWithPostInfo {
 			let sender = ensure_signed(origin)?;
 			let extra_fields = info.additional.len() as u32;
-			ensure!(extra_fields <= T::MaxAdditionalFields::get(), Error::<T>::TooManyFields);
+			ensure!(
+				extra_fields <= T::MaxAdditionalFields::get(),
+				Error::<T>::TooManyFields
+			);
 			let fd = <BalanceOf<T>>::from(extra_fields) * T::FieldDeposit::get();
 
 			let mut id = match <IdentityOf<T>>::get(&sender) {
@@ -367,7 +397,7 @@
 					id.judgements.retain(|j| j.1.is_sticky());
 					id.info = *info;
 					id
-				},
+				}
 				None => Registration {
 					info: *info,
 					judgements: BoundedVec::default(),
@@ -441,8 +471,10 @@
 			let (old_deposit, old_ids) = <SubsOf<T>>::get(&sender);
 			let new_deposit = T::SubAccountDeposit::get() * <BalanceOf<T>>::from(subs.len() as u32);
 
-			let not_other_sub =
-				subs.iter().filter_map(|i| SuperOf::<T>::get(&i.0)).all(|i| i.0 == sender);
+			let not_other_sub = subs
+				.iter()
+				.filter_map(|i| SuperOf::<T>::get(&i.0))
+				.all(|i| i.0 == sender);
 			ensure!(not_other_sub, Error::<T>::AlreadyClaimed);
 
 			if old_deposit < new_deposit {
@@ -459,7 +491,8 @@
 			let mut ids = BoundedVec::<T::AccountId, T::MaxSubAccounts>::default();
 			for (id, name) in subs {
 				<SuperOf<T>>::insert(&id, (sender.clone(), name));
-				ids.try_push(id).expect("subs length is less than T::MaxSubAccounts; qed");
+				ids.try_push(id)
+					.expect("subs length is less than T::MaxSubAccounts; qed");
 			}
 			let new_subs = ids.len();
 
@@ -514,7 +547,10 @@
 			let err_amount = T::Currency::unreserve(&sender, deposit);
 			debug_assert!(err_amount.is_zero());
 
-			Self::deposit_event(Event::IdentityCleared { who: sender, deposit });
+			Self::deposit_event(Event::IdentityCleared {
+				who: sender,
+				deposit,
+			});
 
 			Ok(Some(T::WeightInfo::clear_identity(
 				id.judgements.len() as u32,      // R
@@ -568,14 +604,17 @@
 
 			let item = (reg_index, Judgement::FeePaid(registrar.fee));
 			match id.judgements.binary_search_by_key(&reg_index, |x| x.0) {
-				Ok(i) =>
+				Ok(i) => {
 					if id.judgements[i].1.is_sticky() {
-						return Err(Error::<T>::StickyJudgement.into())
+						return Err(Error::<T>::StickyJudgement.into());
 					} else {
 						id.judgements[i] = item
-					},
-				Err(i) =>
-					id.judgements.try_insert(i, item).map_err(|_| Error::<T>::TooManyRegistrars)?,
+					}
+				}
+				Err(i) => id
+					.judgements
+					.try_insert(i, item)
+					.map_err(|_| Error::<T>::TooManyRegistrars)?,
 			}
 
 			T::Currency::reserve(&sender, registrar.fee)?;
@@ -589,8 +628,11 @@
 				registrar_index: reg_index,
 			});
 
-			Ok(Some(T::WeightInfo::request_judgement(judgements as u32, extra_fields as u32))
-				.into())
+			Ok(Some(T::WeightInfo::request_judgement(
+				judgements as u32,
+				extra_fields as u32,
+			))
+			.into())
 		}
 
 		/// Cancel a previous request.
@@ -629,7 +671,7 @@
 			let fee = if let Judgement::FeePaid(fee) = id.judgements.remove(pos).1 {
 				fee
 			} else {
-				return Err(Error::<T>::JudgementGiven.into())
+				return Err(Error::<T>::JudgementGiven.into());
 			};
 
 			let err_amount = T::Currency::unreserve(&sender, fee);
@@ -643,7 +685,11 @@
 				registrar_index: reg_index,
 			});
 
-			Ok(Some(T::WeightInfo::cancel_request(judgements as u32, extra_fields as u32)).into())
+			Ok(Some(T::WeightInfo::cancel_request(
+				judgements as u32,
+				extra_fields as u32,
+			))
+			.into())
 		}
 
 		/// Set the fee required for a judgement to be requested from a registrar.
@@ -810,7 +856,7 @@
 			let mut id = <IdentityOf<T>>::get(&target).ok_or(Error::<T>::InvalidTarget)?;
 
 			if T::Hashing::hash_of(&id.info) != identity {
-				return Err(Error::<T>::JudgementForDifferentIdentity.into())
+				return Err(Error::<T>::JudgementForDifferentIdentity.into());
 			}
 
 			let item = (reg_index, judgement);
@@ -826,7 +872,7 @@
 						.map_err(|_| Error::<T>::JudgementPaymentFailed)?;
 					}
 					id.judgements[position] = item
-				},
+				}
 				Err(position) => id
 					.judgements
 					.try_insert(position, item)
@@ -836,10 +882,16 @@
 			let judgements = id.judgements.len();
 			let extra_fields = id.info.additional.len();
 			<IdentityOf<T>>::insert(&target, id);
-			Self::deposit_event(Event::JudgementGiven { target, registrar_index: reg_index });
+			Self::deposit_event(Event::JudgementGiven {
+				target,
+				registrar_index: reg_index,
+			});
 
-			Ok(Some(T::WeightInfo::provide_judgement(judgements as u32, extra_fields as u32))
-				.into())
+			Ok(Some(T::WeightInfo::provide_judgement(
+				judgements as u32,
+				extra_fields as u32,
+			))
+			.into())
 		}
 
 		/// Remove an account's identity and sub-account information and slash the deposits.
@@ -885,7 +937,10 @@
 			// Slash their deposit from them.
 			T::Slashed::on_unbalanced(T::Currency::slash_reserved(&target, deposit).0);
 
-			Self::deposit_event(Event::IdentityKilled { who: target, deposit });
+			Self::deposit_event(Event::IdentityKilled {
+				who: target,
+				deposit,
+			});
 
 			Ok(Some(T::WeightInfo::kill_identity(
 				id.judgements.len() as u32,      // R
@@ -911,10 +966,16 @@
 		) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
 			let sub = T::Lookup::lookup(sub)?;
-			ensure!(IdentityOf::<T>::contains_key(&sender), Error::<T>::NoIdentity);
+			ensure!(
+				IdentityOf::<T>::contains_key(&sender),
+				Error::<T>::NoIdentity
+			);
 
 			// Check if it's already claimed as sub-identity.
-			ensure!(!SuperOf::<T>::contains_key(&sub), Error::<T>::AlreadyClaimed);
+			ensure!(
+				!SuperOf::<T>::contains_key(&sub),
+				Error::<T>::AlreadyClaimed
+			);
 
 			SubsOf::<T>::try_mutate(&sender, |(ref mut subs_deposit, ref mut sub_ids)| {
 				// Ensure there is space and that the deposit is paid.
@@ -926,10 +987,16 @@
 				T::Currency::reserve(&sender, deposit)?;
 
 				SuperOf::<T>::insert(&sub, (sender.clone(), data));
-				sub_ids.try_push(sub.clone()).expect("sub ids length checked above; qed");
+				sub_ids
+					.try_push(sub.clone())
+					.expect("sub ids length checked above; qed");
 				*subs_deposit = subs_deposit.saturating_add(deposit);
 
-				Self::deposit_event(Event::SubIdentityAdded { sub, main: sender.clone(), deposit });
+				Self::deposit_event(Event::SubIdentityAdded {
+					sub,
+					main: sender.clone(),
+					deposit,
+				});
 				Ok(())
 			})
 		}
@@ -947,8 +1014,14 @@
 		) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
 			let sub = T::Lookup::lookup(sub)?;
-			ensure!(IdentityOf::<T>::contains_key(&sender), Error::<T>::NoIdentity);
-			ensure!(SuperOf::<T>::get(&sub).map_or(false, |x| x.0 == sender), Error::<T>::NotOwned);
+			ensure!(
+				IdentityOf::<T>::contains_key(&sender),
+				Error::<T>::NoIdentity
+			);
+			ensure!(
+				SuperOf::<T>::get(&sub).map_or(false, |x| x.0 == sender),
+				Error::<T>::NotOwned
+			);
 			SuperOf::<T>::insert(&sub, (sender, data));
 			Ok(())
 		}
@@ -964,7 +1037,10 @@
 		#[pallet::weight(T::WeightInfo::remove_sub(T::MaxSubAccounts::get()))]
 		pub fn remove_sub(origin: OriginFor<T>, sub: AccountIdLookupOf<T>) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
-			ensure!(IdentityOf::<T>::contains_key(&sender), Error::<T>::NoIdentity);
+			ensure!(
+				IdentityOf::<T>::contains_key(&sender),
+				Error::<T>::NoIdentity
+			);
 			let sub = T::Lookup::lookup(sub)?;
 			let (sup, _) = SuperOf::<T>::get(&sub).ok_or(Error::<T>::NotSub)?;
 			ensure!(sup == sender, Error::<T>::NotOwned);
@@ -975,7 +1051,11 @@
 				*subs_deposit -= deposit;
 				let err_amount = T::Currency::unreserve(&sender, deposit);
 				debug_assert!(err_amount.is_zero());
-				Self::deposit_event(Event::SubIdentityRemoved { sub, main: sender, deposit });
+				Self::deposit_event(Event::SubIdentityRemoved {
+					sub,
+					main: sender,
+					deposit,
+				});
 			});
 			Ok(())
 		}
@@ -1024,7 +1104,8 @@
 
 	/// Check if the account has corresponding identity information by the identity field.
 	pub fn has_identity(who: &T::AccountId, fields: u64) -> bool {
-		IdentityOf::<T>::get(who)
-			.map_or(false, |registration| (registration.info.fields().0.bits() & fields) == fields)
+		IdentityOf::<T>::get(who).map_or(false, |registration| {
+			(registration.info.fields().0.bits() & fields) == fields
+		})
 	}
 }

--- a/pallets/identity/src/tests.rs
+++ b/pallets/identity/src/tests.rs
@@ -135,7 +135,9 @@
 }
 
 pub fn new_test_ext() -> sp_io::TestExternalities {
-	let mut t = frame_system::GenesisConfig::default().build_storage::<Test>().unwrap();
+	let mut t = frame_system::GenesisConfig::default()
+		.build_storage::<Test>()
+		.unwrap();
 	pallet_balances::GenesisConfig::<Test> {
 		balances: vec![(1, 10), (2, 10), (3, 10), (10, 100), (20, 100), (30, 100)],
 	}
@@ -155,7 +157,12 @@
 fn twenty() -> IdentityInfo<MaxAdditionalFields> {
 	IdentityInfo {
 		display: Data::Raw(b"twenty".to_vec().try_into().unwrap()),
-		legal: Data::Raw(b"The Right Ordinal Twenty, Esq.".to_vec().try_into().unwrap()),
+		legal: Data::Raw(
+			b"The Right Ordinal Twenty, Esq."
+				.to_vec()
+				.try_into()
+				.unwrap(),
+		),
 		..Default::default()
 	}
 }
@@ -170,7 +177,10 @@
 			Error::<Test>::NoIdentity
 		);
 
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 
 		// first sub account
 		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));
@@ -215,8 +225,14 @@
 	new_test_ext().execute_with(|| {
 		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());
 
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(20), Box::new(twenty())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(20),
+			Box::new(twenty())
+		));
 
 		// 10 claims 1 as a subaccount
 		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));
@@ -258,7 +274,11 @@
 		assert_ok!(Identity::set_fields(RuntimeOrigin::signed(3), 0, fields));
 		assert_eq!(
 			Identity::registrars(),
-			vec![Some(RegistrarInfo { account: 3, fee: 10, fields })]
+			vec![Some(RegistrarInfo {
+				account: 3,
+				fee: 10,
+				fields
+			})]
 		);
 	});
 }
@@ -283,15 +303,30 @@
 		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
 		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
 		let mut three_fields = ten();
-		three_fields.additional.try_push(Default::default()).unwrap();
-		three_fields.additional.try_push(Default::default()).unwrap();
-		assert!(three_fields.additional.try_push(Default::default()).is_err());
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		three_fields
+			.additional
+			.try_push(Default::default())
+			.unwrap();
+		three_fields
+			.additional
+			.try_push(Default::default())
+			.unwrap();
+		assert!(three_fields
+			.additional
+			.try_push(Default::default())
+			.is_err());
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_eq!(Identity::identity(10).unwrap().info, ten());
 		assert_eq!(Balances::free_balance(10), 90);
 		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));
 		assert_eq!(Balances::free_balance(10), 100);
-		assert_noop!(Identity::clear_identity(RuntimeOrigin::signed(10)), Error::<Test>::NotNamed);
+		assert_noop!(
+			Identity::clear_identity(RuntimeOrigin::signed(10)),
+			Error::<Test>::NotNamed
+		);
 	});
 }
 
@@ -321,7 +356,10 @@
 			Error::<Test>::InvalidTarget
 		);
 
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_noop!(
 			Identity::provide_judgement(
 				RuntimeOrigin::signed(3),
@@ -363,7 +401,10 @@
 			Judgement::Reasonable,
 			identity_hash
 		));
-		assert_eq!(Identity::identity(10).unwrap().judgements, vec![(0, Judgement::Reasonable)]);
+		assert_eq!(
+			Identity::identity(10).unwrap().judgements,
+			vec![(0, Judgement::Reasonable)]
+		);
 	});
 }
 
@@ -371,7 +412,10 @@
 fn clearing_judgement_should_work() {
 	new_test_ext().execute_with(|| {
 		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_ok!(Identity::provide_judgement(
 			RuntimeOrigin::signed(3),
 			0,
@@ -387,8 +431,14 @@
 #[test]
 fn killing_slashing_should_work() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
-		assert_noop!(Identity::kill_identity(RuntimeOrigin::signed(1), 10), BadOrigin);
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
+		assert_noop!(
+			Identity::kill_identity(RuntimeOrigin::signed(1), 10),
+			BadOrigin
+		);
 		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));
 		assert_eq!(Identity::identity(10), None);
 		assert_eq!(Balances::free_balance(10), 90);
@@ -408,28 +458,52 @@
 			Error::<Test>::NotFound
 		);
 
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));
 		assert_eq!(Balances::free_balance(10), 80);
 		assert_eq!(Identity::subs_of(10), (10, vec![20].try_into().unwrap()));
-		assert_eq!(Identity::super_of(20), Some((10, Data::Raw(vec![40; 1].try_into().unwrap()))));
+		assert_eq!(
+			Identity::super_of(20),
+			Some((10, Data::Raw(vec![40; 1].try_into().unwrap())))
+		);
 
 		// push another item and re-set it.
 		subs.push((30, Data::Raw(vec![50; 1].try_into().unwrap())));
 		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));
 		assert_eq!(Balances::free_balance(10), 70);
-		assert_eq!(Identity::subs_of(10), (20, vec![20, 30].try_into().unwrap()));
-		assert_eq!(Identity::super_of(20), Some((10, Data::Raw(vec![40; 1].try_into().unwrap()))));
-		assert_eq!(Identity::super_of(30), Some((10, Data::Raw(vec![50; 1].try_into().unwrap()))));
+		assert_eq!(
+			Identity::subs_of(10),
+			(20, vec![20, 30].try_into().unwrap())
+		);
+		assert_eq!(
+			Identity::super_of(20),
+			Some((10, Data::Raw(vec![40; 1].try_into().unwrap())))
+		);
+		assert_eq!(
+			Identity::super_of(30),
+			Some((10, Data::Raw(vec![50; 1].try_into().unwrap())))
+		);
 
 		// switch out one of the items and re-set.
 		subs[0] = (40, Data::Raw(vec![60; 1].try_into().unwrap()));
 		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));
 		assert_eq!(Balances::free_balance(10), 70); // no change in the balance
-		assert_eq!(Identity::subs_of(10), (20, vec![40, 30].try_into().unwrap()));
+		assert_eq!(
+			Identity::subs_of(10),
+			(20, vec![40, 30].try_into().unwrap())
+		);
 		assert_eq!(Identity::super_of(20), None);
-		assert_eq!(Identity::super_of(30), Some((10, Data::Raw(vec![50; 1].try_into().unwrap()))));
-		assert_eq!(Identity::super_of(40), Some((10, Data::Raw(vec![60; 1].try_into().unwrap()))));
+		assert_eq!(
+			Identity::super_of(30),
+			Some((10, Data::Raw(vec![50; 1].try_into().unwrap())))
+		);
+		assert_eq!(
+			Identity::super_of(40),
+			Some((10, Data::Raw(vec![60; 1].try_into().unwrap())))
+		);
 
 		// clear
 		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), vec![]));
@@ -449,7 +523,10 @@
 #[test]
 fn clearing_account_should_remove_subaccounts_and_refund() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_ok!(Identity::set_subs(
 			RuntimeOrigin::signed(10),
 			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]
@@ -463,7 +540,10 @@
 #[test]
 fn killing_account_should_remove_subaccounts_and_not_refund() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_ok!(Identity::set_subs(
 			RuntimeOrigin::signed(10),
 			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]
@@ -483,8 +563,15 @@
 			Identity::cancel_request(RuntimeOrigin::signed(10), 0),
 			Error::<Test>::NoIdentity
 		);
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
-		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
+		assert_ok!(Identity::request_judgement(
+			RuntimeOrigin::signed(10),
+			0,
+			10
+		));
 		assert_ok!(Identity::cancel_request(RuntimeOrigin::signed(10), 0));
 		assert_eq!(Balances::free_balance(10), 90);
 		assert_noop!(
@@ -511,12 +598,19 @@
 	new_test_ext().execute_with(|| {
 		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
 		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert_noop!(
 			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 9),
 			Error::<Test>::FeeChanged
 		);
-		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		assert_ok!(Identity::request_judgement(
+			RuntimeOrigin::signed(10),
+			0,
+			10
+		));
 		// 10 for the judgement request, 10 for the identity.
 		assert_eq!(Balances::free_balance(10), 80);
 
@@ -543,7 +637,11 @@
 
 		// Requesting from a second registrar still works.
 		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 4));
-		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 1, 10));
+		assert_ok!(Identity::request_judgement(
+			RuntimeOrigin::signed(10),
+			1,
+			10
+		));
 
 		// Re-requesting after the judgement has been reduced works.
 		assert_ok!(Identity::provide_judgement(
@@ -553,7 +651,11 @@
 			Judgement::OutOfDate,
 			BlakeTwo256::hash_of(&ten())
 		));
-		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		assert_ok!(Identity::request_judgement(
+			RuntimeOrigin::signed(10),
+			0,
+			10
+		));
 	});
 }
 
@@ -562,8 +664,15 @@
 	new_test_ext().execute_with(|| {
 		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
 		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
-		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
+		assert_ok!(Identity::request_judgement(
+			RuntimeOrigin::signed(10),
+			0,
+			10
+		));
 		// 10 for the judgement request, 10 for the identity.
 		assert_eq!(Balances::free_balance(10), 80);
 
@@ -628,7 +737,10 @@
 #[test]
 fn test_has_identity() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(ten())
+		));
 		assert!(Identity::has_identity(&10, IdentityField::Display as u64));
 		assert!(Identity::has_identity(&10, IdentityField::Legal as u64));
 		assert!(Identity::has_identity(

--- a/pallets/identity/src/types.rs
+++ b/pallets/identity/src/types.rs
@@ -87,7 +87,7 @@
 					.expect("bound checked in match arm condition; qed");
 				input.read(&mut r[..])?;
 				Data::Raw(r)
-			},
+			}
 			34 => Data::BlakeTwo256(<[u8; 32]>::decode(input)?),
 			35 => Data::Sha256(<[u8; 32]>::decode(input)?),
 			36 => Data::Keccak256(<[u8; 32]>::decode(input)?),
@@ -106,7 +106,7 @@
 				let mut r = vec![l as u8 + 1; l + 1];
 				r[1..].copy_from_slice(&x[..l as usize]);
 				r
-			},
+			}
 			Data::BlakeTwo256(ref h) => once(34u8).chain(h.iter().cloned()).collect(),
 			Data::Sha256(ref h) => once(35u8).chain(h.iter().cloned()).collect(),
 			Data::Keccak256(ref h) => once(36u8).chain(h.iter().cloned()).collect(),
@@ -175,19 +175,25 @@
 
 		let variants = variants
 			.variant("BlakeTwo256", |v| {
-				v.index(34).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+				v.index(34)
+					.fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
 			})
 			.variant("Sha256", |v| {
-				v.index(35).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+				v.index(35)
+					.fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
 			})
 			.variant("Keccak256", |v| {
-				v.index(36).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+				v.index(36)
+					.fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
 			})
 			.variant("ShaThree256", |v| {
-				v.index(37).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+				v.index(37)
+					.fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
 			});
 
-		Type::builder().path(Path::new("Data", module_path!())).variant(variants)
+		Type::builder()
+			.path(Path::new("Data", module_path!()))
+			.variant(variants)
 	}
 }
 
@@ -280,7 +286,9 @@
 impl Decode for IdentityFields {
 	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {
 		let field = u64::decode(input)?;
-		Ok(Self(<BitFlags<IdentityField>>::from_bits(field as u64).map_err(|_| "invalid value")?))
+		Ok(Self(
+			<BitFlags<IdentityField>>::from_bits(field as u64).map_err(|_| "invalid value")?,
+		))
 	}
 }
 impl TypeInfo for IdentityFields {
@@ -289,7 +297,10 @@
 	fn type_info() -> Type {
 		Type::builder()
 			.path(Path::new("BitFlags", module_path!()))
-			.type_params(vec![TypeParameter::new("T", Some(meta_type::<IdentityField>()))])
+			.type_params(vec![TypeParameter::new(
+				"T",
+				Some(meta_type::<IdentityField>()),
+			)])
 			.composite(Fields::unnamed().field(|f| f.ty::<u64>().type_name("IdentityField")))
 	}
 }
@@ -413,10 +424,17 @@
 	> Registration<Balance, MaxJudgements, MaxAdditionalFields>
 {
 	pub(crate) fn total_deposit(&self) -> Balance {
-		self.deposit +
-			self.judgements
+		self.deposit
+			+ self
+				.judgements
 				.iter()
-				.map(|(_, ref j)| if let Judgement::FeePaid(fee) = j { *fee } else { Zero::zero() })
+				.map(|(_, ref j)| {
+					if let Judgement::FeePaid(fee) = j {
+						*fee
+					} else {
+						Zero::zero()
+					}
+				})
 				.fold(Zero::zero(), |a, i| a + i)
 	}
 }
@@ -429,7 +447,11 @@
 {
 	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {
 		let (judgements, deposit, info) = Decode::decode(&mut AppendZerosInput::new(input))?;
-		Ok(Self { judgements, deposit, info })
+		Ok(Self {
+			judgements,
+			deposit,
+			info,
+		})
 	}
 }
 

--- a/runtime/common/config/pallets/collator_selection.rs
+++ b/runtime/common/config/pallets/collator_selection.rs
@@ -54,9 +54,10 @@
 }
 
 parameter_types! {
-	pub const BasicDeposit: Balance = 10 * UNIQUE; // todo:collator
+	// These do not matter as we forbid non-sudo operations with the identity pallet
+	pub const BasicDeposit: Balance = 10 * UNIQUE;
 	pub const FieldDeposit: Balance = 25 * MILLIUNIQUE;
-	pub const SubAccountDeposit: Balance = 2 * UNIQUE; // end todo
+	pub const SubAccountDeposit: Balance = 2 * UNIQUE;
 	pub const MaxSubAccounts: u32 = 100;
 	pub const MaxAdditionalFields: u32 = 100;
 	pub const MaxRegistrars: u32 = 20;
@@ -89,7 +90,6 @@
 	type TreasuryAccountId = TreasuryAccountId;
 	type PotId = PotId;
 	type MaxCollators = MaxCollators;
-	// todo:collator kick threshold should be in storage and configured only by root -- or rather UpdateOrigin
 	type SlashRatio = SlashRatio;
 	type ValidatorId = <Self as frame_system::Config>::AccountId;
 	type ValidatorIdOf = pallet_collator_selection::IdentityCollator;

--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -705,7 +705,6 @@
                     #[cfg(feature = "rmrk")]
                     list_benchmark!(list, extra, pallet_proxy_rmrk_equip, RmrkEquip);
 
-                    // todo:collator check benchmarks
                     #[cfg(feature = "collator-selection")]
                     list_benchmark!(list, extra, pallet_collator_selection, CollatorSelection);
 
@@ -772,7 +771,6 @@
                     #[cfg(feature = "rmrk")]
                     add_benchmark!(params, batches, pallet_proxy_rmrk_equip, RmrkEquip);
 
-                    // todo:collator check benchmarks
                     #[cfg(feature = "collator-selection")]
                     add_benchmark!(params, batches, pallet_collator_selection, CollatorSelection);
 

--- a/runtime/opal/Cargo.toml
+++ b/runtime/opal/Cargo.toml
@@ -39,6 +39,7 @@
     'pallet-unique/runtime-benchmarks',
     'pallet-inflation/runtime-benchmarks',
     'pallet-app-promotion/runtime-benchmarks',
+    'pallet-collator-selection/runtime-benchmarks',
     'pallet-unique-scheduler-v2/runtime-benchmarks',
     'pallet-xcm/runtime-benchmarks',
     'sp-runtime/runtime-benchmarks',