Identity Deposits Relay to Parachain Migration

polkadot/runtime/rococo/src/impls.rs

@@ -0,0 +1,115 @@
+// 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 pallet_identity::OnReapIdentity;
+use primitives::Balance;
+use rococo_runtime_constants::currency::*;
+use sp_std::{marker::PhantomData, prelude::*};
+use xcm::{latest::prelude::*, /* v2::OriginKind, */ VersionedMultiLocation, VersionedXcm};
+use xcm_executor::traits::TransactAsset;
+
+/// 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<T>(PhantomData<T>);
+impl<AccountId, T> OnReapIdentity<AccountId> for ToParachainIdentityReaper<T>
+where
+	T: frame_system::Config + pallet_xcm::Config,
+	AccountId: Into<[u8; 32]> + Clone,
+{
+	fn on_reap_identity(who: &AccountId, fields: u32, subs: u32) -> DispatchResult {
+		// calculate deposit needed on parachains
+		// assume `relay_deposit / 100 + ED + buffer`
+		// buffer to cover tx fees on para, maybe ED
+		let para_basic_deposit = 1000 * CENTS / 100;
+		let para_field_deposit = 250 * CENTS / 100;
+		let para_sub_account_deposit = 200 * CENTS / 100;
+		let para_existential_deposit = EXISTENTIAL_DEPOSIT / 10;
+		let id_deposit =
+			para_basic_deposit.saturating_add(para_field_deposit.saturating_mul(fields as Balance));
+
+		let subs_deposit = para_sub_account_deposit.saturating_mul(subs as Balance);
+
+		let total_to_send = id_deposit
+			.saturating_add(subs_deposit)
+			.saturating_add(para_existential_deposit.saturating_mul(2));
+
+		// define asset / destination from relay perspective
+		let roc: MultiAssets =
+			vec![MultiAsset { id: Concrete(Here.into_location()), fun: Fungible(total_to_send) }]
+				.into();
+		// todo: people chain para id
+		let destination: MultiLocation = MultiLocation::new(0, Parachain(1000));
+
+		// 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.inner().first().unwrap(), // <- safe unwrap since we just set `roc`.
+			// not used in AssetTransactor
+			&XcmContext { origin: None, message_id: [0; 32], topic: None },
+		)
+		.map_err(|_| pallet_xcm::Error::<T>::InvalidAsset)?;
+		xcm_config::LocalAssetTransactor::check_out(
+			&destination,
+			&roc.inner().first().unwrap(), // <- safe unwrap since we just set `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();
+
+		// 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: Weight {ref_time: 2_000_000_000, proof_size: 16_384},
+			// 	// Need People Chain runtime to encode call.
+			// 	call: DoubleEncoded { encoded: /* pallet_identity::poke_deposit(who) */ },
+			// },
+		]);
+
+		// send
+		let _ = <pallet_xcm::Pallet<T>>::send(
+			RawOrigin::Root.into(),
+			Box::new(VersionedMultiLocation::V3(destination)),
+			Box::new(VersionedXcm::V3(program)),
+		)?;
+		Ok(())
+	}
+}

polkadot/runtime/rococo/src/lib.rs

@@ -110,6 +110,10 @@ mod weights;
 // XCM configurations.
 pub mod xcm_config;
 
+// Implemented types.
+mod impls;
+use impls::ToParachainIdentityReaper;
+
 // Governance and configurations.
 pub mod governance;
 use governance::{
@@ -158,7 +162,15 @@ pub fn native_version() -> NativeVersion {
 pub struct IdentityCalls;
 impl Contains<RuntimeCall> for IdentityCalls {
 	fn contains(c: &RuntimeCall) -> bool {
-		matches!(c, RuntimeCall::Identity(_))
+		match c {
+			// Allow calls to reap identity and poke deposit
+			RuntimeCall::Identity(pallet_identity::Call::reap_identity { .. }) |
+			RuntimeCall::Identity(pallet_identity::Call::poke_deposit { .. }) => false,
+			// Block all other calls to identity
+			RuntimeCall::Identity(_) => true,
+			// Allow all other calls
+			_ => false,
+		}
 	}
 }
 
@@ -619,6 +631,11 @@ impl pallet_identity::Config for Runtime {
 	type Slashed = Treasury;
 	type ForceOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;
 	type RegistrarOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;
+	// Should be `EnsureRoot` until the parachain launches with Identity state. Then, it will be
+	// `EnsureSigned<Self::AccountId>` to allow deposit migration.
+	type ReapOrigin = EnsureRoot<Self::AccountId>;
+	type ReapIdentityHandler = ToParachainIdentityReaper<Runtime>;
+	type LockerOrigin = EnsureRoot<Self::AccountId>;
 	type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;
 }
 

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

@@ -351,4 +351,64 @@ impl<T: frame_system::Config> pallet_identity::WeightInfo for WeightInfo<T> {
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(2))
 	}
+	/// 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:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// 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 `s` is `[0, 100]`.
+	fn reap_identity(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `673 + s * (32 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 312_504_000 picoseconds.
+		Weight::from_parts(372_110_300, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			// Standard Error: 481_670
+			.saturating_add(Weight::from_parts(14_580_194, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(T::DbWeight::get().writes((1_u64).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:  `628`
+		//  Estimated: `11003`
+		// Minimum execution time: 525_039_000 picoseconds.
+		Weight::from_parts(554_552_000, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Identity::Locked` (r:0 w:1)
+	/// Proof: `Identity::Locked` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`)
+	fn lock_pallet() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 43_286_000 picoseconds.
+		Weight::from_parts(51_523_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::Locked` (r:0 w:1)
+	/// Proof: `Identity::Locked` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`)
+	fn unlock_pallet() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 42_243_000 picoseconds.
+		Weight::from_parts(52_907_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
 }

polkadot/runtime/westend/src/lib.rs

@@ -887,6 +887,9 @@ impl pallet_identity::Config for Runtime {
 	type MaxRegistrars = MaxRegistrars;
 	type ForceOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;
 	type RegistrarOrigin = EitherOf<EnsureRoot<Self::AccountId>, GeneralAdmin>;
+	type ReapOrigin = EnsureRoot<Self::AccountId>;
+	type ReapIdentityHandler = ();
+	type LockerOrigin = EnsureRoot<Self::AccountId>;
 	type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;
 }
 

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

@@ -356,4 +356,64 @@ impl<T: frame_system::Config> pallet_identity::WeightInfo for WeightInfo<T> {
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(2))
 	}
+	/// 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:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// 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 `s` is `[0, 100]`.
+	fn reap_identity(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `673 + s * (32 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 312_504_000 picoseconds.
+		Weight::from_parts(372_110_300, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			// Standard Error: 481_670
+			.saturating_add(Weight::from_parts(14_580_194, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(T::DbWeight::get().writes((1_u64).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:  `628`
+		//  Estimated: `11003`
+		// Minimum execution time: 525_039_000 picoseconds.
+		Weight::from_parts(554_552_000, 0)
+			.saturating_add(Weight::from_parts(0, 11003))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Identity::Locked` (r:0 w:1)
+	/// Proof: `Identity::Locked` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`)
+	fn lock_pallet() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 43_286_000 picoseconds.
+		Weight::from_parts(51_523_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::Locked` (r:0 w:1)
+	/// Proof: `Identity::Locked` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`)
+	fn unlock_pallet() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 42_243_000 picoseconds.
+		Weight::from_parts(52_907_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
 }

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

@@ -1476,6 +1476,9 @@ impl pallet_identity::Config for Runtime {
 	type Slashed = Treasury;
 	type ForceOrigin = EnsureRootOrHalfCouncil;
 	type RegistrarOrigin = EnsureRootOrHalfCouncil;
+	type ReapOrigin = EnsureRoot<Self::AccountId>;
+	type ReapIdentityHandler = ();
+	type LockerOrigin = EnsureRoot<Self::AccountId>;
 	type WeightInfo = pallet_identity::weights::SubstrateWeight<Runtime>;
 }
 

substrate/frame/alliance/src/mock.rs

@@ -123,7 +123,10 @@ impl pallet_identity::Config for Test {
 	type MaxRegistrars = MaxRegistrars;
 	type Slashed = ();
 	type RegistrarOrigin = EnsureOneOrRoot;
+	type ReapOrigin = EnsureOneOrRoot;
+	type ReapIdentityHandler = ();
 	type ForceOrigin = EnsureTwoOrRoot;
+	type LockerOrigin = EnsureTwoOrRoot;
 	type WeightInfo = ();
 }