Identity Deposits Relay to Parachain Migration (#1814)

The goal of this PR is to migrate Identity deposits from the Relay Chain
to a system parachain.

The problem I want to solve is that `IdentityOf` and `SubsOf` both store
an amount that's held in reserve as a storage deposit. When migrating to
a parachain, we can take a snapshot of the actual `IdentityInfo` and
sub-account mappings, but should migrate (off chain) the `deposit`s to
zero, since the chain (and by extension, accounts) won't have any funds
at genesis.

The good news is that we expect parachain deposits to be significantly
lower (possibly 100x) on the parachain. That is, a deposit of 21 DOT on
the Relay Chain would need 0.21 DOT on a parachain. This PR proposes to
migrate the deposits in the following way:

1. Introduces a new pallet with two extrinsics: 
- `reap_identity`: Has a configurable `ReapOrigin`, which would be set
to `EnsureSigned` on the Relay Chain (i.e. callable by anyone) and
`EnsureRoot` on the parachain (we don't want identities reaped from
there).
- `poke_deposit`: Checks what deposit the pallet holds (at genesis,
zero) and attempts to update the amount based on the calculated deposit
for storage data.
2. `reap_identity` clears all storage data for a `target` account and
unreserves their deposit.
3. A `ReapIdentityHandler` teleports the necessary DOT to the parachain
and calls `poke_deposit`. Since the parachain deposit is much lower, and
was just unreserved, we know we have enough.

One awkwardness I ran into was that the XCMv3 instruction set does not
provide a way for the system to teleport assets without a fee being
deducted on reception. Users shouldn't have to pay a fee for the system
to migrate their info to a more efficient location. So I wrote my own
program and did the `InitiateTeleport` accounting on my own to send a
program with `UnpaidExecution`. Have discussed an
`InitiateUnpaidTeleport` instruction with @franciscoaguirre . Obviously
any chain executing this would have to pass a `Barrier` for free
execution.

TODO:

- [x] Confirm People Chain ParaId
- [x] Confirm People Chain deposit rates (determined in
https://github.com/paritytech/polkadot-sdk/pull/2281)
- [x] Add pallet to Westend

---------

Co-authored-by: Bastian Köcher <git@kchr.de>

Cargo.lock

@@ -13047,6 +13047,7 @@ dependencies = [
  "pallet-balances",
  "pallet-election-provider-multi-phase",
  "pallet-fast-unstake",
+ "pallet-identity",
  "pallet-session",
  "pallet-staking",
  "pallet-staking-reward-fn",

polkadot/runtime/common/Cargo.toml

@@ -30,6 +30,7 @@ sp-npos-elections = { path = "../../../substrate/primitives/npos-elections", def
 pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false }
 pallet-balances = { path = "../../../substrate/frame/balances", default-features = false }
 pallet-fast-unstake = { path = "../../../substrate/frame/fast-unstake", default-features = false }
+pallet-identity = { path = "../../../substrate/frame/identity", default-features = false }
 pallet-session = { path = "../../../substrate/frame/session", default-features = false }
 frame-support = { path = "../../../substrate/frame/support", default-features = false }
 pallet-staking = { path = "../../../substrate/frame/staking", default-features = false }
@@ -85,6 +86,7 @@ std = [
 	"pallet-balances/std",
 	"pallet-election-provider-multi-phase/std",
 	"pallet-fast-unstake/std",
+	"pallet-identity/std",
 	"pallet-session/std",
 	"pallet-staking-reward-fn/std",
 	"pallet-staking/std",
@@ -124,6 +126,7 @@ runtime-benchmarks = [
 	"pallet-balances/runtime-benchmarks",
 	"pallet-election-provider-multi-phase/runtime-benchmarks",
 	"pallet-fast-unstake/runtime-benchmarks",
+	"pallet-identity/runtime-benchmarks",
 	"pallet-staking/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
 	"pallet-treasury/runtime-benchmarks",
@@ -147,6 +150,7 @@ try-runtime = [
 	"pallet-balances/try-runtime",
 	"pallet-election-provider-multi-phase/try-runtime",
 	"pallet-fast-unstake/try-runtime",
+	"pallet-identity/try-runtime",
 	"pallet-session/try-runtime",
 	"pallet-staking/try-runtime",
 	"pallet-timestamp/try-runtime",

polkadot/runtime/common/src/identity_migrator.rs

@@ -0,0 +1,305 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! This pallet is designed to go into a source chain and destination chain to migrate data. The
+//! design motivations are:
+//!
+//! - Call some function on the source chain that executes some migration (clearing state,
+//!   forwarding an XCM program).
+//! - Call some function (probably from an XCM program) on the destination chain.
+//! - Avoid cluttering the source pallet with new dispatchables that are unrelated to its
+//!   functionality and only used for migration.
+//!
+//! After the migration is complete, the pallet may be removed from both chains' runtimes as well as
+//! the `polkadot-runtime-common` crate.
+
+use frame_support::{dispatch::DispatchResult, traits::Currency, weights::Weight};
+pub use pallet::*;
+use pallet_identity;
+use sp_core::Get;
+
+#[cfg(feature = "runtime-benchmarks")]
+use frame_benchmarking::{account, impl_benchmark_test_suite, v2::*, BenchmarkError};
+
+pub trait WeightInfo {
+	fn reap_identity(r: u32, s: u32) -> Weight;
+	fn poke_deposit() -> Weight;
+}
+
+impl WeightInfo for () {
+	fn reap_identity(_r: u32, _s: u32) -> Weight {
+		Weight::MAX
+	}
+	fn poke_deposit() -> Weight {
+		Weight::MAX
+	}
+}
+
+pub struct TestWeightInfo;
+impl WeightInfo for TestWeightInfo {
+	fn reap_identity(_r: u32, _s: u32) -> Weight {
+		Weight::zero()
+	}
+	fn poke_deposit() -> Weight {
+		Weight::zero()
+	}
+}
+
+// Must use the same `Balance` as `T`'s Identity pallet to handle deposits.
+type BalanceOf<T> = <<T as pallet_identity::Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::Balance;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		dispatch::{DispatchResultWithPostInfo, PostDispatchInfo},
+		pallet_prelude::*,
+		traits::EnsureOrigin,
+	};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + pallet_identity::Config {
+		/// Overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The origin that can reap identities. Expected to be `EnsureSigned<AccountId>` on the
+		/// source chain such that anyone can all this function.
+		type Reaper: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// A handler for what to do when an identity is reaped.
+		type ReapIdentityHandler: OnReapIdentity<Self::AccountId>;
+
+		/// Weight information for the extrinsics in the pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// The identity and all sub accounts were reaped for `who`.
+		IdentityReaped { who: T::AccountId },
+		/// The deposits held for `who` were updated. `identity` is the new deposit held for
+		/// identity info, and `subs` is the new deposit held for the sub-accounts.
+		DepositUpdated { who: T::AccountId, identity: BalanceOf<T>, subs: BalanceOf<T> },
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Reap the `IdentityInfo` of `who` from the Identity pallet of `T`, unreserving any
+		/// deposits held and removing storage items associated with `who`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as pallet::Config>::WeightInfo::reap_identity(
+				T::MaxRegistrars::get(),
+				T::MaxSubAccounts::get()
+		))]
+		pub fn reap_identity(
+			origin: OriginFor<T>,
+			who: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			T::Reaper::ensure_origin(origin)?;
+			// - number of registrars (required to calculate weight)
+			// - byte size of `IdentityInfo` (required to calculate remote deposit)
+			// - number of sub accounts (required to calculate both weight and remote deposit)
+			let (registrars, bytes, subs) = pallet_identity::Pallet::<T>::reap_identity(&who)?;
+			T::ReapIdentityHandler::on_reap_identity(&who, bytes, subs)?;
+			Self::deposit_event(Event::IdentityReaped { who });
+			let post = PostDispatchInfo {
+				actual_weight: Some(<T as pallet::Config>::WeightInfo::reap_identity(
+					registrars, subs,
+				)),
+				pays_fee: Pays::No,
+			};
+			Ok(post)
+		}
+
+		/// Update the deposit of `who`. Meant to be called by the system with an XCM `Transact`
+		/// Instruction.
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as pallet::Config>::WeightInfo::poke_deposit())]
+		pub fn poke_deposit(origin: OriginFor<T>, who: T::AccountId) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			let (id_deposit, subs_deposit) = pallet_identity::Pallet::<T>::poke_deposit(&who)?;
+			Self::deposit_event(Event::DepositUpdated {
+				who,
+				identity: id_deposit,
+				subs: subs_deposit,
+			});
+			Ok(Pays::No.into())
+		}
+	}
+}
+
+/// Trait to handle reaping identity from state.
+pub trait OnReapIdentity<AccountId> {
+	/// What to do when an identity is reaped. For example, the implementation could send an XCM
+	/// program to another chain. Concretely, a type implementing this trait in the Polkadot
+	/// runtime would teleport enough DOT to the People Chain to cover the Identity deposit there.
+	///
+	/// This could also directly include `Transact { poke_deposit(..), ..}`.
+	///
+	/// Inputs
+	/// - `who`: Whose identity was reaped.
+	/// - `bytes`: The byte size of `IdentityInfo`.
+	/// - `subs`: The number of sub-accounts they had.
+	fn on_reap_identity(who: &AccountId, bytes: u32, subs: u32) -> DispatchResult;
+}
+
+impl<AccountId> OnReapIdentity<AccountId> for () {
+	fn on_reap_identity(_who: &AccountId, _bytes: u32, _subs: u32) -> DispatchResult {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+	use frame_support::traits::EnsureOrigin;
+	use frame_system::RawOrigin;
+	use pallet_identity::{Data, IdentityInformationProvider, Judgement, Pallet as Identity};
+	use parity_scale_codec::Encode;
+	use sp_runtime::{
+		traits::{Bounded, Hash, StaticLookup},
+		Saturating,
+	};
+	use sp_std::{boxed::Box, vec::Vec, *};
+
+	const SEED: u32 = 0;
+
+	fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+		let events = frame_system::Pallet::<T>::events();
+		let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+		let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+		assert_eq!(event, &system_event);
+	}
+
+	#[benchmark]
+	fn reap_identity(
+		r: Linear<0, { T::MaxRegistrars::get() }>,
+		s: Linear<0, { T::MaxSubAccounts::get() }>,
+	) -> Result<(), BenchmarkError> {
+		// set up target
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_origin =
+			<T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(target.clone()));
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		let _ = T::Currency::make_free_balance_be(&target, BalanceOf::<T>::max_value());
+
+		// set identity
+		let info = <T as pallet_identity::Config>::IdentityInformation::create_identity_info();
+		Identity::<T>::set_identity(
+			RawOrigin::Signed(target.clone()).into(),
+			Box::new(info.clone()),
+		)?;
+
+		// create and set subs
+		let mut subs = Vec::new();
+		let data = Data::Raw(vec![0; 32].try_into().unwrap());
+		for ii in 0..s {
+			let sub_account = account("sub", ii, SEED);
+			subs.push((sub_account, data.clone()));
+		}
+		Identity::<T>::set_subs(target_origin.clone(), subs.clone())?;
+
+		// add registrars and provide judgements
+		let registrar_origin = T::RegistrarOrigin::try_successful_origin()
+			.expect("RegistrarOrigin has no successful origin required for the benchmark");
+		for ii in 0..r {
+			// registrar account
+			let registrar: T::AccountId = account("registrar", ii, SEED);
+			let registrar_lookup = T::Lookup::unlookup(registrar.clone());
+			let _ = <T as pallet_identity::Config>::Currency::make_free_balance_be(
+				&registrar,
+				<T as pallet_identity::Config>::Currency::minimum_balance(),
+			);
+
+			// add registrar
+			Identity::<T>::add_registrar(registrar_origin.clone(), registrar_lookup)?;
+			Identity::<T>::set_fee(RawOrigin::Signed(registrar.clone()).into(), ii, 10u32.into())?;
+			let fields = <T as pallet_identity::Config>::IdentityInformation::all_fields();
+			Identity::<T>::set_fields(RawOrigin::Signed(registrar.clone()).into(), ii, fields)?;
+
+			// request and provide judgement
+			Identity::<T>::request_judgement(target_origin.clone(), ii, 10u32.into())?;
+			Identity::<T>::provide_judgement(
+				RawOrigin::Signed(registrar).into(),
+				ii,
+				target_lookup.clone(),
+				Judgement::Reasonable,
+				<T as frame_system::Config>::Hashing::hash_of(&info),
+			)?;
+		}
+
+		let origin = T::Reaper::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, target.clone());
+
+		assert_last_event::<T>(Event::<T>::IdentityReaped { who: target.clone() }.into());
+
+		let fields = <T as pallet_identity::Config>::IdentityInformation::all_fields();
+		assert!(!Identity::<T>::has_identity(&target, fields));
+		assert_eq!(Identity::<T>::subs(&target).len(), 0);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn poke_deposit() -> Result<(), BenchmarkError> {
+		let target: T::AccountId = account("target", 0, SEED);
+		let _ = T::Currency::make_free_balance_be(&target, BalanceOf::<T>::max_value());
+		let info = <T as pallet_identity::Config>::IdentityInformation::create_identity_info();
+
+		let _ = Identity::<T>::set_identity_no_deposit(&target, info.clone());
+
+		let sub_account: T::AccountId = account("sub", 0, SEED);
+		let _ = Identity::<T>::set_sub_no_deposit(&target, sub_account.clone());
+
+		// expected deposits
+		let expected_id_deposit = <T as pallet_identity::Config>::BasicDeposit::get()
+			.saturating_add(
+				<T as pallet_identity::Config>::ByteDeposit::get()
+					.saturating_mul(<BalanceOf<T>>::from(info.encoded_size() as u32)),
+			);
+		// only 1 sub
+		let expected_sub_deposit = <T as pallet_identity::Config>::SubAccountDeposit::get();
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, target.clone());
+
+		assert_last_event::<T>(
+			Event::<T>::DepositUpdated {
+				who: target,
+				identity: expected_id_deposit,
+				subs: expected_sub_deposit,
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		crate::integration_tests::new_test_ext(),
+		crate::integration_tests::Test,
+	);
+}

polkadot/runtime/common/src/integration_tests.rs

@@ -17,7 +17,7 @@
 //! Mocking utilities for testing with real pallets.
 
 use crate::{
-	auctions, crowdloan,
+	auctions, crowdloan, identity_migrator,
 	mock::{conclude_pvf_checking, validators_public_keys},
 	paras_registrar,
 	slot_range::SlotRange,
@@ -32,6 +32,7 @@ use frame_support::{
 };
 use frame_support_test::TestRandomness;
 use frame_system::EnsureRoot;
+use pallet_identity::{self, legacy::IdentityInfo};
 use parity_scale_codec::Encode;
 use primitives::{
 	BlockNumber, HeadData, Id as ParaId, SessionIndex, ValidationCode, LOWEST_PUBLIC_ID,
@@ -88,6 +89,10 @@ frame_support::construct_runtime!(
 		Auctions: auctions::{Pallet, Call, Storage, Event<T>},
 		Crowdloan: crowdloan::{Pallet, Call, Storage, Event<T>},
 		Slots: slots::{Pallet, Call, Storage, Event<T>},
+
+		// Migrators
+		Identity: pallet_identity::{Pallet, Call, Storage, Event<T>},
+		IdentityMigrator: identity_migrator::{Pallet, Call, Event<T>},
 	}
 );
 
@@ -274,6 +279,28 @@ impl crowdloan::Config for Test {
 	type WeightInfo = crate::crowdloan::TestWeightInfo;
 }
 
+impl pallet_identity::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type Slashed = ();
+	type BasicDeposit = ConstU32<100>;
+	type ByteDeposit = ConstU32<10>;
+	type SubAccountDeposit = ConstU32<100>;
+	type MaxSubAccounts = ConstU32<2>;
+	type IdentityInformation = IdentityInfo<ConstU32<2>>;
+	type MaxRegistrars = ConstU32<20>;
+	type RegistrarOrigin = EnsureRoot<AccountId>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type WeightInfo = ();
+}
+
+impl identity_migrator::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Reaper = EnsureRoot<AccountId>;
+	type ReapIdentityHandler = ();
+	type WeightInfo = crate::identity_migrator::TestWeightInfo;
+}
+
 /// Create a new set of test externalities.
 pub fn new_test_ext() -> TestExternalities {
 	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();

polkadot/runtime/common/src/lib.rs

@@ -23,6 +23,7 @@ pub mod auctions;
 pub mod claims;
 pub mod crowdloan;
 pub mod elections;
+pub mod identity_migrator;
 pub mod impls;
 pub mod paras_registrar;
 pub mod paras_sudo_wrapper;

polkadot/runtime/rococo/src/impls.rs

@@ -0,0 +1,158 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::xcm_config;
+use frame_support::pallet_prelude::DispatchResult;
+use frame_system::RawOrigin;
+use parity_scale_codec::{Decode, Encode};
+use primitives::Balance;
+use rococo_runtime_constants::currency::*;
+use runtime_common::identity_migrator::{OnReapIdentity, WeightInfo};
+use sp_std::{marker::PhantomData, prelude::*};
+use xcm::{latest::prelude::*, VersionedMultiLocation, VersionedXcm};
+use xcm_executor::traits::TransactAsset;
+
+/// A type containing the encoding of the People Chain pallets in its runtime. Used to construct any
+/// remote calls. The codec index must correspond to the index of `IdentityMigrator` in the
+/// `construct_runtime` of the remote chain.
+#[derive(Encode, Decode)]
+enum PeopleRuntimePallets<AccountId: Encode> {
+	#[codec(index = 248)]
+	IdentityMigrator(IdentityMigratorCalls<AccountId>),
+}
+
+/// Call encoding for the calls needed from the Identity Migrator pallet.
+#[derive(Encode, Decode)]
+enum IdentityMigratorCalls<AccountId: Encode> {
+	#[codec(index = 1)]
+	PokeDeposit(AccountId),
+}
+
+/// Type that implements `OnReapIdentity` that will send the deposit needed to store the same
+/// information on a parachain, sends the deposit there, and then updates it.
+pub struct ToParachainIdentityReaper<Runtime, AccountId>(PhantomData<(Runtime, AccountId)>);
+impl<Runtime, AccountId> ToParachainIdentityReaper<Runtime, AccountId> {
+	/// Calculate the balance needed on the remote chain based on the `IdentityInfo` and `Subs` on
+	/// this chain. The total includes:
+	///
+	/// - Identity basic deposit
+	/// - `IdentityInfo` byte deposit
+	/// - Sub accounts deposit
+	/// - 2x existential deposit (1 for account existence, 1 such that the user can transact)
+	fn calculate_remote_deposit(bytes: u32, subs: u32) -> Balance {
+		// Remote deposit constants. Parachain uses `deposit / 100`
+		// Source:
+		// https://github.com/paritytech/polkadot-sdk/blob/a146918/cumulus/parachains/common/src/rococo.rs#L29
+		//
+		// Parachain Deposit Configuration:
+		//
+		// pub const BasicDeposit: Balance = deposit(1, 17);
+		// pub const ByteDeposit: Balance = deposit(0, 1);
+		// pub const SubAccountDeposit: Balance = deposit(1, 53);
+		// pub const EXISTENTIAL_DEPOSIT: Balance = constants::currency::EXISTENTIAL_DEPOSIT / 10;
+		let para_basic_deposit = deposit(1, 17) / 100;
+		let para_byte_deposit = deposit(0, 1) / 100;
+		let para_sub_account_deposit = deposit(1, 53) / 100;
+		let para_existential_deposit = EXISTENTIAL_DEPOSIT / 10;
+
+		// pallet deposits
+		let id_deposit =
+			para_basic_deposit.saturating_add(para_byte_deposit.saturating_mul(bytes as Balance));
+		let subs_deposit = para_sub_account_deposit.saturating_mul(subs as Balance);
+
+		id_deposit
+			.saturating_add(subs_deposit)
+			.saturating_add(para_existential_deposit.saturating_mul(2))
+	}
+}
+
+impl<Runtime, AccountId> OnReapIdentity<AccountId> for ToParachainIdentityReaper<Runtime, AccountId>
+where
+	Runtime: frame_system::Config + pallet_xcm::Config,
+	AccountId: Into<[u8; 32]> + Clone + Encode,
+{
+	fn on_reap_identity(who: &AccountId, fields: u32, subs: u32) -> DispatchResult {
+		use crate::{
+			impls::IdentityMigratorCalls::PokeDeposit,
+			weights::runtime_common_identity_migrator::WeightInfo as MigratorWeights,
+		};
+
+		let total_to_send = Self::calculate_remote_deposit(fields, subs);
+
+		// define asset / destination from relay perspective
+		let roc = MultiAsset { id: Concrete(Here.into_location()), fun: Fungible(total_to_send) };
+		// People Chain: ParaId 1004
+		let destination: MultiLocation = MultiLocation::new(0, Parachain(1004));
+
+		// Do `check_out` accounting since the XCM Executor's `InitiateTeleport` doesn't support
+		// unpaid teleports.
+
+		// check out
+		xcm_config::LocalAssetTransactor::can_check_out(
+			&destination,
+			&roc,
+			// not used in AssetTransactor
+			&XcmContext { origin: None, message_id: [0; 32], topic: None },
+		)
+		.map_err(|_| pallet_xcm::Error::<Runtime>::CannotCheckOutTeleport)?;
+		xcm_config::LocalAssetTransactor::check_out(
+			&destination,
+			&roc,
+			// not used in AssetTransactor
+			&XcmContext { origin: None, message_id: [0; 32], topic: None },
+		);
+
+		// reanchor
+		let roc_reanchored: MultiAssets = vec![MultiAsset {
+			id: Concrete(MultiLocation::new(1, Here)),
+			fun: Fungible(total_to_send),
+		}]
+		.into();
+
+		let poke = PeopleRuntimePallets::<AccountId>::IdentityMigrator(PokeDeposit(who.clone()));
+		let remote_weight_limit = MigratorWeights::<Runtime>::poke_deposit().saturating_mul(2);
+
+		// Actual program to execute on People Chain.
+		let program: Xcm<()> = Xcm(vec![
+			// Unpaid as this is constructed by the system, once per user. The user shouldn't have
+			// their balance reduced by teleport fees for the favor of migrating.
+			UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+			// Receive the asset into holding.
+			ReceiveTeleportedAsset(roc_reanchored),
+			// Deposit into the user's account.
+			DepositAsset {
+				assets: Wild(AllCounted(1)),
+				beneficiary: Junction::AccountId32 { network: None, id: who.clone().into() }
+					.into_location()
+					.into(),
+			},
+			// Poke the deposit to reserve the appropriate amount on the parachain.
+			Transact {
+				origin_kind: OriginKind::Superuser,
+				require_weight_at_most: remote_weight_limit,
+				call: poke.encode().into(),
+			},
+		]);
+
+		// send
+		let _ = <pallet_xcm::Pallet<Runtime>>::send(
+			RawOrigin::Root.into(),
+			Box::new(VersionedMultiLocation::V3(destination)),
+			Box::new(VersionedXcm::V3(program)),
+		)?;
+		Ok(())
+	}
+}

polkadot/runtime/rococo/src/lib.rs

@@ -31,7 +31,7 @@ use primitives::{
 	ValidatorIndex, PARACHAIN_KEY_TYPE_ID,
 };
 use runtime_common::{
-	assigned_slots, auctions, claims, crowdloan, impl_runtime_weights,
+	assigned_slots, auctions, claims, crowdloan, identity_migrator, impl_runtime_weights,
 	impls::{
 		LocatableAssetConverter, ToAuthor, VersionedLocatableAsset, VersionedMultiLocationConverter,
 	},
@@ -68,9 +68,9 @@ use frame_support::{
 	genesis_builder_helper::{build_config, create_default_config},
 	parameter_types,
 	traits::{
-		fungible::HoldConsideration, EitherOf, EitherOfDiverse, Everything, InstanceFilter,
-		KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage, ProcessMessageError,
-		StorageMapShim, WithdrawReasons,
+		fungible::HoldConsideration, Contains, EitherOf, EitherOfDiverse, EverythingBut,
+		InstanceFilter, KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage,
+		ProcessMessageError, StorageMapShim, WithdrawReasons,
 	},
 	weights::{ConstantMultiplier, WeightMeter},
 	PalletId,
@@ -114,6 +114,10 @@ mod weights;
 // XCM configurations.
 pub mod xcm_config;
 
+// Implemented types.
+mod impls;
+use impls::ToParachainIdentityReaper;
+
 // Governance and configurations.
 pub mod governance;
 use governance::{
@@ -166,13 +170,24 @@ pub fn native_version() -> NativeVersion {
 	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
 }
 
+/// A type to identify calls to the Identity pallet. These will be filtered to prevent invocation,
+/// locking the state of the pallet and preventing further updates to identities and sub-identities.
+/// The locked state will be the genesis state of a new system chain and then removed from the Relay
+/// Chain.
+pub struct IsIdentityCall;
+impl Contains<RuntimeCall> for IsIdentityCall {
+	fn contains(c: &RuntimeCall) -> bool {
+		matches!(c, RuntimeCall::Identity(_))
+	}
+}
+
 parameter_types! {
 	pub const Version: RuntimeVersion = VERSION;
 	pub const SS58Prefix: u8 = 42;
 }
 
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = Everything;
+	type BaseCallFilter = EverythingBut<IsIdentityCall>;
 	type BlockWeights = BlockWeights;
 	type BlockLength = BlockLength;
 	type DbWeight = RocksDbWeight;
@@ -1079,6 +1094,14 @@ impl auctions::Config for Runtime {
 	type WeightInfo = weights::runtime_common_auctions::WeightInfo<Runtime>;
 }
 
+impl identity_migrator::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	// To be changed to `EnsureSigned` once there is a People Chain to migrate to.
+	type Reaper = EnsureRoot<AccountId>;
+	type ReapIdentityHandler = ToParachainIdentityReaper<Runtime, Self::AccountId>;
+	type WeightInfo = weights::runtime_common_identity_migrator::WeightInfo<Runtime>;
+}
+
 type NisCounterpartInstance = pallet_balances::Instance2;
 impl pallet_balances::Config<NisCounterpartInstance> for Runtime {
 	type Balance = Balance;
@@ -1340,7 +1363,7 @@ construct_runtime! {
 
 		// NIS pallet.
 		Nis: pallet_nis::{Pallet, Call, Storage, Event<T>, HoldReason} = 38,
-//		pub type NisCounterpartInstance = pallet_balances::Instance2;
+		// pub type NisCounterpartInstance = pallet_balances::Instance2;
 		NisCounterpartBalances: pallet_balances::<Instance2> = 45,
 
 		// Parachains pallets. Start indices at 50 to leave room.
@@ -1371,6 +1394,9 @@ construct_runtime! {
 		// Pallet for sending XCM.
 		XcmPallet: pallet_xcm::{Pallet, Call, Storage, Event<T>, Origin, Config<T>} = 99,
 
+		// Pallet for migrating Identity to a parachain. To be removed post-migration.
+		IdentityMigrator: identity_migrator::{Pallet, Call, Event<T>} = 248,
+
 		ParasSudoWrapper: paras_sudo_wrapper::{Pallet, Call} = 250,
 		AssignedSlots: assigned_slots::{Pallet, Call, Storage, Event<T>, Config<T>} = 251,
 
@@ -1551,6 +1577,7 @@ mod benches {
 		[runtime_common::auctions, Auctions]
 		[runtime_common::crowdloan, Crowdloan]
 		[runtime_common::claims, Claims]
+		[runtime_common::identity_migrator, IdentityMigrator]
 		[runtime_common::slots, Slots]
 		[runtime_common::paras_registrar, Registrar]
 		[runtime_parachains::configuration, Configuration]

polkadot/runtime/rococo/src/weights/mod.rs

@@ -46,6 +46,7 @@ pub mod runtime_common_assigned_slots;
 pub mod runtime_common_auctions;
 pub mod runtime_common_claims;
 pub mod runtime_common_crowdloan;
+pub mod runtime_common_identity_migrator;
 pub mod runtime_common_paras_registrar;
 pub mod runtime_common_slots;
 pub mod runtime_parachains_assigner_on_demand;

polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs

@@ -0,0 +1,97 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Autogenerated weights for `runtime_common::identity_migrator`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-11-07, STEPS: `2`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `sbtb`, CPU: `13th Gen Intel(R) Core(TM) i7-1365U`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/polkadot
+// benchmark
+// pallet
+// --chain=rococo-dev
+// --steps=2
+// --repeat=1
+// --pallet=runtime_common::identity_migrator
+// --extrinsic=*
+// --output=./migrator-release.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `runtime_common::identity_migrator`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: frame_system::Config> runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmPallet::SupportedVersion` (r:1 w:0)
+	/// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1)
+	/// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1)
+	/// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Identity::SuperOf` (r:0 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[0, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	fn reap_identity(r: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `7292 + r * (8 ±0) + s * (32 ±0)`
+		//  Estimated: `11003 + r * (8 ±0) + s * (33 ±0)`
+		// Minimum execution time: 163_756_000 picoseconds.
+		Weight::from_parts(158_982_500, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			// Standard Error: 1_143_629
+			.saturating_add(Weight::from_parts(238_675, 0).saturating_mul(r.into()))
+			// Standard Error: 228_725
+			.saturating_add(Weight::from_parts(1_529_645, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(8))
+			.saturating_add(T::DbWeight::get().writes(5))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into()))
+			.saturating_add(Weight::from_parts(0, 33).saturating_mul(s.into()))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	fn poke_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `7229`
+		//  Estimated: `11003`
+		// Minimum execution time: 137_570_000 picoseconds.
+		Weight::from_parts(137_570_000, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+}

polkadot/runtime/westend/src/impls.rs

@@ -0,0 +1,158 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::xcm_config;
+use frame_support::pallet_prelude::DispatchResult;
+use frame_system::RawOrigin;
+use parity_scale_codec::{Decode, Encode};
+use primitives::Balance;
+use runtime_common::identity_migrator::{OnReapIdentity, WeightInfo};
+use sp_std::{marker::PhantomData, prelude::*};
+use westend_runtime_constants::currency::*;
+use xcm::{latest::prelude::*, VersionedMultiLocation, VersionedXcm};
+use xcm_executor::traits::TransactAsset;
+
+/// A type containing the encoding of the People Chain pallets in its runtime. Used to construct any
+/// remote calls. The codec index must correspond to the index of `IdentityMigrator` in the
+/// `construct_runtime` of the remote chain.
+#[derive(Encode, Decode)]
+enum PeopleRuntimePallets<AccountId: Encode> {
+	#[codec(index = 248)]
+	IdentityMigrator(IdentityMigratorCalls<AccountId>),
+}
+
+/// Call encoding for the calls needed from the Identity Migrator pallet.
+#[derive(Encode, Decode)]
+enum IdentityMigratorCalls<AccountId: Encode> {
+	#[codec(index = 1)]
+	PokeDeposit(AccountId),
+}
+
+/// Type that implements `OnReapIdentity` that will send the deposit needed to store the same
+/// information on a parachain, sends the deposit there, and then updates it.
+pub struct ToParachainIdentityReaper<Runtime, AccountId>(PhantomData<(Runtime, AccountId)>);
+impl<Runtime, AccountId> ToParachainIdentityReaper<Runtime, AccountId> {
+	/// Calculate the balance needed on the remote chain based on the `IdentityInfo` and `Subs` on
+	/// this chain. The total includes:
+	///
+	/// - Identity basic deposit
+	/// - `IdentityInfo` byte deposit
+	/// - Sub accounts deposit
+	/// - 2x existential deposit (1 for account existence, 1 such that the user can transact)
+	fn calculate_remote_deposit(bytes: u32, subs: u32) -> Balance {
+		// Remote deposit constants. Parachain uses `deposit / 100`
+		// Source:
+		// https://github.com/paritytech/polkadot-sdk/blob/a146918/cumulus/parachains/common/src/westend.rs#L28
+		//
+		// Parachain Deposit Configuration:
+		//
+		// pub const BasicDeposit: Balance = deposit(1, 17);
+		// pub const ByteDeposit: Balance = deposit(0, 1);
+		// pub const SubAccountDeposit: Balance = deposit(1, 53);
+		// pub const EXISTENTIAL_DEPOSIT: Balance = constants::currency::EXISTENTIAL_DEPOSIT / 10;
+		let para_basic_deposit = deposit(1, 17) / 100;
+		let para_byte_deposit = deposit(0, 1) / 100;
+		let para_sub_account_deposit = deposit(1, 53) / 100;
+		let para_existential_deposit = EXISTENTIAL_DEPOSIT / 10;
+
+		// pallet deposits
+		let id_deposit =
+			para_basic_deposit.saturating_add(para_byte_deposit.saturating_mul(bytes as Balance));
+		let subs_deposit = para_sub_account_deposit.saturating_mul(subs as Balance);
+
+		id_deposit
+			.saturating_add(subs_deposit)
+			.saturating_add(para_existential_deposit.saturating_mul(2))
+	}
+}
+
+impl<Runtime, AccountId> OnReapIdentity<AccountId> for ToParachainIdentityReaper<Runtime, AccountId>
+where
+	Runtime: frame_system::Config + pallet_xcm::Config,
+	AccountId: Into<[u8; 32]> + Clone + Encode,
+{
+	fn on_reap_identity(who: &AccountId, fields: u32, subs: u32) -> DispatchResult {
+		use crate::{
+			impls::IdentityMigratorCalls::PokeDeposit,
+			weights::runtime_common_identity_migrator::WeightInfo as MigratorWeights,
+		};
+
+		let total_to_send = Self::calculate_remote_deposit(fields, subs);
+
+		// define asset / destination from relay perspective
+		let wnd = MultiAsset { id: Concrete(Here.into_location()), fun: Fungible(total_to_send) };
+		// People Chain: ParaId 1004
+		let destination: MultiLocation = MultiLocation::new(0, Parachain(1004));
+
+		// Do `check_out` accounting since the XCM Executor's `InitiateTeleport` doesn't support
+		// unpaid teleports.
+
+		// check out
+		xcm_config::LocalAssetTransactor::can_check_out(
+			&destination,
+			&wnd,
+			// not used in AssetTransactor
+			&XcmContext { origin: None, message_id: [0; 32], topic: None },
+		)
+		.map_err(|_| pallet_xcm::Error::<Runtime>::CannotCheckOutTeleport)?;
+		xcm_config::LocalAssetTransactor::check_out(
+			&destination,
+			&wnd,
+			// not used in AssetTransactor
+			&XcmContext { origin: None, message_id: [0; 32], topic: None },
+		);
+
+		// reanchor
+		let wnd_reanchored: MultiAssets = vec![MultiAsset {
+			id: Concrete(MultiLocation::new(1, Here)),
+			fun: Fungible(total_to_send),
+		}]
+		.into();
+
+		let poke = PeopleRuntimePallets::<AccountId>::IdentityMigrator(PokeDeposit(who.clone()));
+		let remote_weight_limit = MigratorWeights::<Runtime>::poke_deposit().saturating_mul(2);
+
+		// Actual program to execute on People Chain.
+		let program: Xcm<()> = Xcm(vec![
+			// Unpaid as this is constructed by the system, once per user. The user shouldn't have
+			// their balance reduced by teleport fees for the favor of migrating.
+			UnpaidExecution { weight_limit: Unlimited, check_origin: None },
+			// Receive the asset into holding.
+			ReceiveTeleportedAsset(wnd_reanchored),
+			// Deposit into the user's account.
+			DepositAsset {
+				assets: Wild(AllCounted(1)),
+				beneficiary: Junction::AccountId32 { network: None, id: who.clone().into() }
+					.into_location()
+					.into(),
+			},
+			// Poke the deposit to reserve the appropriate amount on the parachain.
+			Transact {
+				origin_kind: OriginKind::Superuser,
+				require_weight_at_most: remote_weight_limit,
+				call: poke.encode().into(),
+			},
+		]);
+
+		// send
+		let _ = <pallet_xcm::Pallet<Runtime>>::send(
+			RawOrigin::Root.into(),
+			Box::new(VersionedMultiLocation::V3(destination)),
+			Box::new(VersionedXcm::V3(program)),
+		)?;
+		Ok(())
+	}
+}

polkadot/runtime/westend/src/lib.rs

@@ -31,7 +31,7 @@ use frame_support::{
 	genesis_builder_helper::{build_config, create_default_config},
 	parameter_types,
 	traits::{
-		fungible::HoldConsideration, ConstU32, EitherOf, EitherOfDiverse, Everything,
+		fungible::HoldConsideration, ConstU32, Contains, EitherOf, EitherOfDiverse, EverythingBut,
 		InstanceFilter, KeyOwnerProofSystem, LinearStoragePrice, ProcessMessage,
 		ProcessMessageError, WithdrawReasons,
 	},
@@ -56,7 +56,7 @@ use primitives::{
 use runtime_common::{
 	assigned_slots, auctions, crowdloan,
 	elections::OnChainAccuracy,
-	impl_runtime_weights,
+	identity_migrator, impl_runtime_weights,
 	impls::{
 		LocatableAssetConverter, ToAuthor, VersionedLocatableAsset, VersionedMultiLocationConverter,
 	},
@@ -119,6 +119,10 @@ mod bag_thresholds;
 mod weights;
 pub mod xcm_config;
 
+// Implemented types.
+mod impls;
+use impls::ToParachainIdentityReaper;
+
 // Governance and configurations.
 pub mod governance;
 use governance::{
@@ -161,13 +165,24 @@ pub fn native_version() -> NativeVersion {
 	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
 }
 
+/// A type to identify calls to the Identity pallet. These will be filtered to prevent invocation,
+/// locking the state of the pallet and preventing further updates to identities and sub-identities.
+/// The locked state will be the genesis state of a new system chain and then removed from the Relay
+/// Chain.
+pub struct IsIdentityCall;
+impl Contains<RuntimeCall> for IsIdentityCall {
+	fn contains(c: &RuntimeCall) -> bool {
+		matches!(c, RuntimeCall::Identity(_))
+	}
+}
+
 parameter_types! {
 	pub const Version: RuntimeVersion = VERSION;
 	pub const SS58Prefix: u8 = 42;
 }
 
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = Everything;
+	type BaseCallFilter = EverythingBut<IsIdentityCall>;
 	type BlockWeights = BlockWeights;
 	type BlockLength = BlockLength;
 	type RuntimeOrigin = RuntimeOrigin;
@@ -1328,6 +1343,14 @@ impl auctions::Config for Runtime {
 	type WeightInfo = weights::runtime_common_auctions::WeightInfo<Runtime>;
 }
 
+impl identity_migrator::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	// To be changed to `EnsureSigned` once there is a People Chain to migrate to.
+	type Reaper = EnsureRoot<AccountId>;
+	type ReapIdentityHandler = ToParachainIdentityReaper<Runtime, Self::AccountId>;
+	type WeightInfo = weights::runtime_common_identity_migrator::WeightInfo<Runtime>;
+}
+
 parameter_types! {
 	pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
 	pub const MaxPointsToBalance: u8 = 10;
@@ -1491,6 +1514,9 @@ construct_runtime! {
 
 		// Root testing pallet.
 		RootTesting: pallet_root_testing::{Pallet, Call, Storage, Event<T>} = 102,
+
+		// Pallet for migrating Identity to a parachain. To be removed post-migration.
+		IdentityMigrator: identity_migrator::{Pallet, Call, Event<T>} = 248,
 	}
 }
 
@@ -1587,6 +1613,7 @@ mod benches {
 		[runtime_common::assigned_slots, AssignedSlots]
 		[runtime_common::auctions, Auctions]
 		[runtime_common::crowdloan, Crowdloan]
+		[runtime_common::identity_migrator, IdentityMigrator]
 		[runtime_common::paras_registrar, Registrar]
 		[runtime_common::slots, Slots]
 		[runtime_parachains::configuration, Configuration]

polkadot/runtime/westend/src/weights/mod.rs

@@ -46,6 +46,7 @@ pub mod pallet_xcm;
 pub mod runtime_common_assigned_slots;
 pub mod runtime_common_auctions;
 pub mod runtime_common_crowdloan;
+pub mod runtime_common_identity_migrator;
 pub mod runtime_common_paras_registrar;
 pub mod runtime_common_slots;
 pub mod runtime_parachains_configuration;

polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs

@@ -0,0 +1,97 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Autogenerated weights for `runtime_common::identity_migrator`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-11-07, STEPS: `2`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `sbtb`, CPU: `13th Gen Intel(R) Core(TM) i7-1365U`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/polkadot
+// benchmark
+// pallet
+// --chain=rococo-dev
+// --steps=2
+// --repeat=1
+// --pallet=runtime_common::identity_migrator
+// --extrinsic=*
+// --output=./migrator-release.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `runtime_common::identity_migrator`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: frame_system::Config> runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmPallet::SupportedVersion` (r:1 w:0)
+	/// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1)
+	/// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1)
+	/// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Identity::SuperOf` (r:0 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[0, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	fn reap_identity(r: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `7292 + r * (8 ±0) + s * (32 ±0)`
+		//  Estimated: `11003 + r * (8 ±0) + s * (33 ±0)`
+		// Minimum execution time: 163_756_000 picoseconds.
+		Weight::from_parts(158_982_500, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			// Standard Error: 1_143_629
+			.saturating_add(Weight::from_parts(238_675, 0).saturating_mul(r.into()))
+			// Standard Error: 228_725
+			.saturating_add(Weight::from_parts(1_529_645, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(8))
+			.saturating_add(T::DbWeight::get().writes(5))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into()))
+			.saturating_add(Weight::from_parts(0, 33).saturating_mul(s.into()))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	fn poke_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `7229`
+		//  Estimated: `11003`
+		// Minimum execution time: 137_570_000 picoseconds.
+		Weight::from_parts(137_570_000, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+}

substrate/frame/identity/src/lib.rs

@@ -79,8 +79,10 @@ mod tests;
 mod types;
 pub mod weights;
 
+use codec::Encode;
 use frame_support::{
-	pallet_prelude::DispatchResult,
+	ensure,
+	pallet_prelude::{DispatchError, DispatchResult},
 	traits::{BalanceStatus, Currency, Get, OnUnbalanced, ReservableCurrency},
 };
 use sp_runtime::traits::{AppendZerosInput, Hash, Saturating, StaticLookup, Zero};
@@ -395,8 +397,7 @@ pub mod pallet {
 			);
 
 			let (old_deposit, old_ids) = <SubsOf<T>>::get(&sender);
-			let new_deposit =
-				T::SubAccountDeposit::get().saturating_mul(<BalanceOf<T>>::from(subs.len() as u32));
+			let new_deposit = Self::subs_deposit(subs.len() as u32);
 
 			let not_other_sub =
 				subs.iter().filter_map(|i| SuperOf::<T>::get(&i.0)).all(|i| i.0 == sender);
@@ -898,6 +899,26 @@ impl<T: Config> Pallet<T> {
 			.collect()
 	}
 
+	/// Calculate the deposit required for a number of `sub` accounts.
+	fn subs_deposit(subs: u32) -> BalanceOf<T> {
+		T::SubAccountDeposit::get().saturating_mul(<BalanceOf<T>>::from(subs))
+	}
+
+	/// Take the `current` deposit that `who` is holding, and update it to a `new` one.
+	fn rejig_deposit(
+		who: &T::AccountId,
+		current: BalanceOf<T>,
+		new: BalanceOf<T>,
+	) -> DispatchResult {
+		if new > current {
+			T::Currency::reserve(who, new - current)?;
+		} else if new < current {
+			let err_amount = T::Currency::unreserve(who, current - new);
+			debug_assert!(err_amount.is_zero());
+		}
+		Ok(())
+	}
+
 	/// Check if the account has corresponding identity information by the identity field.
 	pub fn has_identity(
 		who: &T::AccountId,
@@ -906,4 +927,110 @@ impl<T: Config> Pallet<T> {
 		IdentityOf::<T>::get(who)
 			.map_or(false, |registration| (registration.info.has_identity(fields)))
 	}
+
+	/// Reap an identity, clearing associated storage items and refunding any deposits. This
+	/// function is very similar to (a) `clear_identity`, but called on a `target` account instead
+	/// of self; and (b) `kill_identity`, but without imposing a slash.
+	///
+	/// Parameters:
+	/// - `target`: The account for which to reap identity state.
+	///
+	/// Return type is a tuple of the number of registrars, `IdentityInfo` bytes, and sub accounts,
+	/// respectively.
+	///
+	/// NOTE: This function is here temporarily for migration of Identity info from the Polkadot
+	/// Relay Chain into a system parachain. It will be removed after the migration.
+	pub fn reap_identity(who: &T::AccountId) -> Result<(u32, u32, u32), DispatchError> {
+		// `take` any storage items keyed by `target`
+		// identity
+		let id = <IdentityOf<T>>::take(&who).ok_or(Error::<T>::NotNamed)?;
+		let registrars = id.judgements.len() as u32;
+		let encoded_byte_size = id.info.encoded_size() as u32;
+
+		// subs
+		let (subs_deposit, sub_ids) = <SubsOf<T>>::take(&who);
+		let actual_subs = sub_ids.len() as u32;
+		for sub in sub_ids.iter() {
+			<SuperOf<T>>::remove(sub);
+		}
+
+		// unreserve any deposits
+		let deposit = id.total_deposit().saturating_add(subs_deposit);
+		let err_amount = T::Currency::unreserve(&who, deposit);
+		debug_assert!(err_amount.is_zero());
+		Ok((registrars, encoded_byte_size, actual_subs))
+	}
+
+	/// Update the deposits held by `target` for its identity info.
+	///
+	/// Parameters:
+	/// - `target`: The account for which to update deposits.
+	///
+	/// Return type is a tuple of the new Identity and Subs deposits, respectively.
+	///
+	/// NOTE: This function is here temporarily for migration of Identity info from the Polkadot
+	/// Relay Chain into a system parachain. It will be removed after the migration.
+	pub fn poke_deposit(
+		target: &T::AccountId,
+	) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError> {
+		// Identity Deposit
+		let new_id_deposit = IdentityOf::<T>::try_mutate(
+			&target,
+			|registration| -> Result<BalanceOf<T>, DispatchError> {
+				let reg = registration.as_mut().ok_or(Error::<T>::NoIdentity)?;
+				// Calculate what deposit should be
+				let encoded_byte_size = reg.info.encoded_size() as u32;
+				let byte_deposit =
+					T::ByteDeposit::get().saturating_mul(<BalanceOf<T>>::from(encoded_byte_size));
+				let new_id_deposit = T::BasicDeposit::get().saturating_add(byte_deposit);
+
+				// Update account
+				Self::rejig_deposit(&target, reg.deposit, new_id_deposit)?;
+
+				reg.deposit = new_id_deposit;
+				Ok(new_id_deposit)
+			},
+		)?;
+
+		// Subs Deposit
+		let new_subs_deposit = SubsOf::<T>::try_mutate(
+			&target,
+			|(current_subs_deposit, subs_of)| -> Result<BalanceOf<T>, DispatchError> {
+				let new_subs_deposit = Self::subs_deposit(subs_of.len() as u32);
+				Self::rejig_deposit(&target, *current_subs_deposit, new_subs_deposit)?;
+				*current_subs_deposit = new_subs_deposit;
+				Ok(new_subs_deposit)
+			},
+		)?;
+		Ok((new_id_deposit, new_subs_deposit))
+	}
+
+	/// Set an identity with zero deposit. Only used for benchmarking that involves `rejig_deposit`.
+	#[cfg(feature = "runtime-benchmarks")]
+	pub fn set_identity_no_deposit(
+		who: &T::AccountId,
+		info: T::IdentityInformation,
+	) -> DispatchResult {
+		IdentityOf::<T>::insert(
+			&who,
+			Registration {
+				judgements: Default::default(),
+				deposit: Zero::zero(),
+				info: info.clone(),
+			},
+		);
+		Ok(())
+	}
+
+	/// Set subs with zero deposit. Only used for benchmarking that involves `rejig_deposit`.
+	#[cfg(feature = "runtime-benchmarks")]
+	pub fn set_sub_no_deposit(who: &T::AccountId, sub: T::AccountId) -> DispatchResult {
+		use frame_support::BoundedVec;
+		let subs = BoundedVec::<_, T::MaxSubAccounts>::try_from(vec![sub]).unwrap();
+		SubsOf::<T>::insert::<
+			&T::AccountId,
+			(BalanceOf<T>, BoundedVec<T::AccountId, T::MaxSubAccounts>),
+		>(&who, (Zero::zero(), subs));
+		Ok(())
+	}
 }

substrate/frame/identity/src/tests.rs

@@ -712,3 +712,70 @@ fn test_has_identity() {
 		));
 	});
 }
+
+#[test]
+fn reap_identity_works() {
+	new_test_ext().execute_with(|| {
+		let ten_info = ten();
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten_info.clone())));
+		assert_ok!(Identity::set_subs(
+			RuntimeOrigin::signed(10),
+			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]
+		));
+		// deposit is correct
+		let id_deposit = id_deposit(&ten_info);
+		let subs_deposit: u64 = <<Test as Config>::SubAccountDeposit as Get<u64>>::get();
+		assert_eq!(Balances::free_balance(10), 1000 - id_deposit - subs_deposit);
+		// reap
+		assert_ok!(Identity::reap_identity(&10));
+		// no identity or subs
+		assert!(Identity::identity(10).is_none());
+		assert!(Identity::super_of(20).is_none());
+		// balance is unreserved
+		assert_eq!(Balances::free_balance(10), 1000);
+	});
+}
+
+#[test]
+fn poke_deposit_works() {
+	new_test_ext().execute_with(|| {
+		let ten_info = ten();
+		// Set a custom registration with 0 deposit
+		IdentityOf::<Test>::insert(
+			&10,
+			Registration {
+				judgements: BoundedVec::default(),
+				deposit: Zero::zero(),
+				info: ten_info.clone(),
+			},
+		);
+		assert!(Identity::identity(10).is_some());
+		// Set a sub with zero deposit
+		SubsOf::<Test>::insert::<&u64, (u64, BoundedVec<u64, ConstU32<2>>)>(
+			&10,
+			(0, vec![20].try_into().unwrap()),
+		);
+		SuperOf::<Test>::insert(&20, (&10, Data::Raw(vec![1; 1].try_into().unwrap())));
+		// Balance is free
+		assert_eq!(Balances::free_balance(10), 1000);
+
+		// poke
+		assert_ok!(Identity::poke_deposit(&10));
+
+		// free balance reduced correctly
+		let id_deposit = id_deposit(&ten_info);
+		let subs_deposit: u64 = <<Test as Config>::SubAccountDeposit as Get<u64>>::get();
+		assert_eq!(Balances::free_balance(10), 1000 - id_deposit - subs_deposit);
+		// new registration deposit is 10
+		assert_eq!(
+			Identity::identity(&10),
+			Some(Registration {
+				judgements: BoundedVec::default(),
+				deposit: id_deposit,
+				info: ten()
+			})
+		);
+		// new subs deposit is 10          vvvvvvvvvvvv
+		assert_eq!(Identity::subs_of(10), (subs_deposit, vec![20].try_into().unwrap()));
+	});
+}