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
#2281)
- [x] Add pallet to Westend

---------

Co-authored-by: Bastian Köcher <[email protected]>

Author: joepetrowski

Cargo.lock

@@ -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/Cargo.toml

@@ -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,
+	);
+}