// This file is part of Substrate.

// 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.

//! # Identity Pallet

//!

//! - [`Config`]

//! - [`Call`]

//!

//! ## Overview

//!

//! A federated naming system, allowing for multiple registrars to be added from a specified origin.

//! Registrars can set a fee to provide identity-verification service. Anyone can put forth a

//! proposed identity for a fixed deposit and ask for review by any number of registrars (paying

//! each of their fees). Registrar judgements are given as an `enum`, allowing for sophisticated,

//! multi-tier opinions.

//!

//! Some judgements are identified as *sticky*, which means they cannot be removed except by

//! complete removal of the identity, or by the registrar. Judgements are allowed to represent a

//! portion of funds that have been reserved for the registrar.

//!

//! A super-user can remove accounts and in doing so, slash the deposit.

//!

//! All accounts may also have a limited number of sub-accounts which may be specified by the owner;

//! by definition, these have equivalent ownership and each has an individual name.

//!

//! The number of registrars should be limited, and the deposit made sufficiently large, to ensure

//! no state-bloat attack is viable.

//!

//! ### Usernames

//!

//! The pallet provides functionality for username authorities to issue usernames. When an account

//! receives a username, they get a default instance of `IdentityInfo`. Usernames also serve as a

//! reverse lookup from username to account.

//!

//! Username authorities are given an allocation by governance to prevent state bloat. Usernames

//! impose no cost or deposit on the user.

//!

//! Users can have multiple usernames that map to the same `AccountId`, however one `AccountId` can

//! only map to a single username, known as the _primary_.

//!

//! ## Interface

//!

//! ### Dispatchable Functions

//!

//! #### For General Users

//! * `set_identity` - Set the associated identity of an account; a small deposit is reserved if not

//!   already taken.

//! * `clear_identity` - Remove an account's associated identity; the deposit is returned.

//! * `request_judgement` - Request a judgement from a registrar, paying a fee.

//! * `cancel_request` - Cancel the previous request for a judgement.

//! * `accept_username` - Accept a username issued by a username authority.

//! * `remove_expired_approval` - Remove a username that was issued but never accepted.

//! * `set_primary_username` - Set a given username as an account's primary.

//! * `remove_dangling_username` - Remove a username that maps to an account without an identity.

//!

//! #### For General Users with Sub-Identities

//! * `set_subs` - Set the sub-accounts of an identity.

//! * `add_sub` - Add a sub-identity to an identity.

//! * `remove_sub` - Remove a sub-identity of an identity.

//! * `rename_sub` - Rename a sub-identity of an identity.

//! * `quit_sub` - Remove a sub-identity of an identity (called by the sub-identity).

//!

//! #### For Registrars

//! * `set_fee` - Set the fee required to be paid for a judgement to be given by the registrar.

//! * `set_fields` - Set the fields that a registrar cares about in their judgements.

//! * `provide_judgement` - Provide a judgement to an identity.

//!

//! #### For Username Authorities

//! * `set_username_for` - Set a username for a given account. The account must approve it.

//!

//! #### For Superusers

//! * `add_registrar` - Add a new registrar to the system.

//! * `kill_identity` - Forcibly remove the associated identity; the deposit is lost.

//! * `add_username_authority` - Add an account with the ability to issue usernames.

//! * `remove_username_authority` - Remove an account with the ability to issue usernames.

//!

//! [`Call`]: ./enum.Call.html

//! [`Config`]: ./trait.Config.html

#![cfg_attr(not(feature = "std"), no_std)]

mod benchmarking;

pub mod legacy;

pub mod migration;

#[cfg(test)]

mod tests;

mod types;

pub mod weights;

extern crate alloc;

use crate::types::{AuthorityPropertiesOf, Suffix, Username};

use alloc::{boxed::Box, vec::Vec};

use codec::Encode;

use frame_support::{

	ensure,

	pallet_prelude::{DispatchError, DispatchResult},

	traits::{BalanceStatus, Currency, Get, OnUnbalanced, ReservableCurrency, StorageVersion},

	BoundedVec,

};

pub use pallet::*;

use sp_runtime::traits::{

	AppendZerosInput, Hash, IdentifyAccount, Saturating, StaticLookup, Verify, Zero,

};

pub use types::{

	Data, IdentityInformationProvider, Judgement, RegistrarIndex, RegistrarInfo, Registration,

};

pub use weights::WeightInfo;

type BalanceOf<T> =

	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;

type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<

	<T as frame_system::Config>::AccountId,

>>::NegativeImbalance;

type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;

pub mod pallet {

	use super::*;

	use frame_support::pallet_prelude::*;

	use frame_system::pallet_prelude::*;

	#[pallet::config]

	pub trait Config: frame_system::Config {

		/// The overarching event type.

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// The currency trait.

		type Currency: ReservableCurrency<Self::AccountId>;

		/// The amount held on deposit for a registered identity.

		#[pallet::constant]

		type BasicDeposit: Get<BalanceOf<Self>>;

		/// The amount held on deposit per encoded byte for a registered identity.

		#[pallet::constant]

		type ByteDeposit: Get<BalanceOf<Self>>;

		/// The amount held on deposit for a registered subaccount. This should account for the fact

		/// that one storage item's value will increase by the size of an account ID, and there will

		/// be another trie item whose value is the size of an account ID plus 32 bytes.

		#[pallet::constant]

		type SubAccountDeposit: Get<BalanceOf<Self>>;

		/// The maximum number of sub-accounts allowed per identified account.

		#[pallet::constant]

		type MaxSubAccounts: Get<u32>;

		/// Structure holding information about an identity.

		type IdentityInformation: IdentityInformationProvider;

		/// Maximum number of registrars allowed in the system. Needed to bound the complexity

		/// of, e.g., updating judgements.

		#[pallet::constant]

		type MaxRegistrars: Get<u32>;

		/// What to do with slashed funds.

		type Slashed: OnUnbalanced<NegativeImbalanceOf<Self>>;

		/// The origin which may forcibly set or remove a name. Root can always do this.

		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// The origin which may add or remove registrars. Root can always do this.

		type RegistrarOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Signature type for pre-authorizing usernames off-chain.

		///

		/// Can verify whether an `Self::SigningPublicKey` created a signature.

		type OffchainSignature: Verify<Signer = Self::SigningPublicKey> + Parameter;

		/// Public key that corresponds to an on-chain `Self::AccountId`.

		type SigningPublicKey: IdentifyAccount<AccountId = Self::AccountId>;

		/// The origin which may add or remove username authorities. Root can always do this.

		type UsernameAuthorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// The number of blocks within which a username grant must be accepted.

		#[pallet::constant]

		type PendingUsernameExpiration: Get<BlockNumberFor<Self>>;

		/// The maximum length of a suffix.

		#[pallet::constant]

		type MaxSuffixLength: Get<u32>;

		/// The maximum length of a username, including its suffix and any system-added delimiters.

		#[pallet::constant]

		type MaxUsernameLength: Get<u32>;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

	}

	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);

	#[pallet::storage_version(STORAGE_VERSION)]

	pub struct Pallet<T>(_);

	/// Information that is pertinent to identify the entity behind an account. First item is the

	/// registration, second is the account's primary username.

	///

	/// TWOX-NOTE: OK ― `AccountId` is a secure hash.

	#[pallet::getter(fn identity)]

	pub(super) type IdentityOf<T: Config> = StorageMap<

		_,

		Twox64Concat,

		T::AccountId,

		(Registration<BalanceOf<T>, T::MaxRegistrars, T::IdentityInformation>, Option<Username<T>>),

		OptionQuery,

	>;

	/// The super-identity of an alternative "sub" identity together with its name, within that

	/// context. If the account is not some other account's sub-identity, then just `None`.

	#[pallet::getter(fn super_of)]

	pub(super) type SuperOf<T: Config> =

		StorageMap<_, Blake2_128Concat, T::AccountId, (T::AccountId, Data), OptionQuery>;

	/// Alternative "sub" identities of this account.

	///

	/// The first item is the deposit, the second is a vector of the accounts.

	///

	/// TWOX-NOTE: OK ― `AccountId` is a secure hash.

	#[pallet::getter(fn subs_of)]

	pub(super) type SubsOf<T: Config> = StorageMap<

		_,

		Twox64Concat,

		T::AccountId,

		(BalanceOf<T>, BoundedVec<T::AccountId, T::MaxSubAccounts>),

		ValueQuery,

	>;

	/// The set of registrars. Not expected to get very big as can only be added through a

	/// special origin (likely a council motion).

	///

	/// The index into this can be cast to `RegistrarIndex` to get a valid value.

	#[pallet::getter(fn registrars)]

	pub(super) type Registrars<T: Config> = StorageValue<

		_,

		BoundedVec<

			Option<

				RegistrarInfo<

					BalanceOf<T>,

					T::AccountId,

					<T::IdentityInformation as IdentityInformationProvider>::FieldsIdentifier,

				>,

			>,

			T::MaxRegistrars,

		>,

		ValueQuery,

	>;

	/// A map of the accounts who are authorized to grant usernames.

	#[pallet::getter(fn authority)]

	pub(super) type UsernameAuthorities<T: Config> =

		StorageMap<_, Twox64Concat, T::AccountId, AuthorityPropertiesOf<T>, OptionQuery>;

	/// Reverse lookup from `username` to the `AccountId` that has registered it. The value should

	/// be a key in the `IdentityOf` map, but it may not if the user has cleared their identity.

	///

	/// Multiple usernames may map to the same `AccountId`, but `IdentityOf` will only map to one

	/// primary username.

	#[pallet::getter(fn username)]

	pub(super) type AccountOfUsername<T: Config> =

		StorageMap<_, Blake2_128Concat, Username<T>, T::AccountId, OptionQuery>;

	/// Usernames that an authority has granted, but that the account controller has not confirmed

	/// that they want it. Used primarily in cases where the `AccountId` cannot provide a signature

	/// because they are a pure proxy, multisig, etc. In order to confirm it, they should call

	/// [`Call::accept_username`].

	///

	/// First tuple item is the account and second is the acceptance deadline.

	#[pallet::getter(fn preapproved_usernames)]

	pub type PendingUsernames<T: Config> = StorageMap<

		_,

		Blake2_128Concat,

		Username<T>,

		(T::AccountId, BlockNumberFor<T>),

		OptionQuery,

	>;

	pub enum Error<T> {

	}

	pub enum Event<T: Config> {

		/// main identity account to the sub-identity account.

		/// identity) has been removed.

	}

	/// Identity pallet declaration.

	impl<T: Config> Pallet<T> {

		/// Add a registrar to the system.

		///

		/// The dispatch origin for this call must be `T::RegistrarOrigin`.

		///

		/// - `account`: the account of the registrar.

		///

		/// Emits `RegistrarAdded` if successful.

		#[pallet::call_index(0)]

		#[pallet::weight(T::WeightInfo::add_registrar(T::MaxRegistrars::get()))]

		pub fn add_registrar(

			origin: OriginFor<T>,

			account: AccountIdLookupOf<T>,

		}

		/// Set an account's identity information and reserve the appropriate deposit.

		///

		/// If the account already has identity information, the deposit is taken as part payment

		/// for the new deposit.

		///

		/// The dispatch origin for this call must be _Signed_.

		///

		/// - `info`: The identity information.

		///

		/// Emits `IdentitySet` if successful.

		#[pallet::call_index(1)]

		#[pallet::weight(T::WeightInfo::set_identity(T::MaxRegistrars::get()))]

		pub fn set_identity(

			origin: OriginFor<T>,

			info: Box<T::IdentityInformation>,

			};

		}

		/// Set the sub-accounts of the sender.

		///

		/// Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned

		/// and an amount `SubAccountDeposit` will be reserved for each item in `subs`.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered

		/// identity.

		///

		/// - `subs`: The identity's (new) sub-accounts.

		// TODO: This whole extrinsic screams "not optimized". For example we could

		// filter any overlap between new and old subs, and avoid reading/writing

		// to those values... We could also ideally avoid needing to write to

		// N storage items for N sub accounts. Right now the weight on this function

		// is a large overestimate due to the fact that it could potentially write

		// to 2 x T::MaxSubAccounts::get().

		#[pallet::call_index(2)]

		#[pallet::weight(T::WeightInfo::set_subs_old(T::MaxSubAccounts::get())

			.saturating_add(T::WeightInfo::set_subs_new(subs.len() as u32))

		)]

		pub fn set_subs(

			origin: OriginFor<T>,

			subs: Vec<(T::AccountId, Data)>,

			);

			// do nothing if they're equal.

		}

		/// Clear an account's identity info and all sub-accounts and return all deposits.

		///

		/// Payment: All reserved balances on the account are returned.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered

		/// identity.

		///

		/// Emits `IdentityCleared` if successful.

		#[pallet::call_index(3)]

		#[pallet::weight(T::WeightInfo::clear_identity(

			T::MaxRegistrars::get(),

			T::MaxSubAccounts::get(),

		))]

		}

		/// Request a judgement from a registrar.

		///

		/// Payment: At most `max_fee` will be reserved for payment to the registrar if judgement

		/// given.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a

		/// registered identity.

		///

		/// - `reg_index`: The index of the registrar whose judgement is requested.

		/// - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:

		///

		/// ```nocompile

		/// Self::registrars().get(reg_index).unwrap().fee

		/// ```

		///

		/// Emits `JudgementRequested` if successful.

		#[pallet::call_index(4)]

		#[pallet::weight(T::WeightInfo::request_judgement(T::MaxRegistrars::get(),))]

		pub fn request_judgement(

			origin: OriginFor<T>,

			#[pallet::compact] reg_index: RegistrarIndex,

			#[pallet::compact] max_fee: BalanceOf<T>,

					} else {

					},

			}

		}

		/// Cancel a previous request.

		///

		/// Payment: A previously reserved deposit is returned on success.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a

		/// registered identity.

		///

		/// - `reg_index`: The index of the registrar whose judgement is no longer requested.

		///

		/// Emits `JudgementUnrequested` if successful.

		#[pallet::call_index(5)]

		#[pallet::weight(T::WeightInfo::cancel_request(T::MaxRegistrars::get()))]

		pub fn cancel_request(

			origin: OriginFor<T>,

			reg_index: RegistrarIndex,

			} else {

			};

		}

		/// Set the fee required for a judgement to be requested from a registrar.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must be the account

		/// of the registrar whose index is `index`.

		///

		/// - `index`: the index of the registrar whose fee is to be set.

		/// - `fee`: the new fee.

		#[pallet::call_index(6)]

		#[pallet::weight(T::WeightInfo::set_fee(T::MaxRegistrars::get()))]

		pub fn set_fee(

			origin: OriginFor<T>,

			#[pallet::compact] index: RegistrarIndex,

			#[pallet::compact] fee: BalanceOf<T>,

						} else {

						}

		}

		/// Change the account associated with a registrar.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must be the account

		/// of the registrar whose index is `index`.

		///

		/// - `index`: the index of the registrar whose fee is to be set.

		/// - `new`: the new account ID.

		#[pallet::call_index(7)]

		#[pallet::weight(T::WeightInfo::set_account_id(T::MaxRegistrars::get()))]

		pub fn set_account_id(

			origin: OriginFor<T>,

			#[pallet::compact] index: RegistrarIndex,

			new: AccountIdLookupOf<T>,

						} else {

						}

		}

		/// Set the field information for a registrar.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must be the account

		/// of the registrar whose index is `index`.

		///

		/// - `index`: the index of the registrar whose fee is to be set.

		/// - `fields`: the fields that the registrar concerns themselves with.

		#[pallet::call_index(8)]

		#[pallet::weight(T::WeightInfo::set_fields(T::MaxRegistrars::get()))]

		pub fn set_fields(

			origin: OriginFor<T>,

			#[pallet::compact] index: RegistrarIndex,

			fields: <T::IdentityInformation as IdentityInformationProvider>::FieldsIdentifier,

		}

		/// Provide a judgement for an account's identity.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must be the account

		/// of the registrar whose index is `reg_index`.

		///

		/// - `reg_index`: the index of the registrar whose judgement is being made.

		/// - `target`: the account whose identity the judgement is upon. This must be an account

		///   with a registered identity.

		/// - `judgement`: the judgement of the registrar of index `reg_index` about `target`.

		/// - `identity`: The hash of the [`IdentityInformationProvider`] for that the judgement is

		///   provided.

		///

		/// Note: Judgements do not apply to a username.

		///

		/// Emits `JudgementGiven` if successful.

		#[pallet::call_index(9)]

		#[pallet::weight(T::WeightInfo::provide_judgement(T::MaxRegistrars::get()))]

		pub fn provide_judgement(

			origin: OriginFor<T>,

			#[pallet::compact] reg_index: RegistrarIndex,

			target: AccountIdLookupOf<T>,

			judgement: Judgement<BalanceOf<T>>,

			identity: T::Hash,

				},

			}

		}

		/// Remove an account's identity and sub-account information and slash the deposits.

		///

		/// Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by

		/// `Slash`. Verification request deposits are not returned; they should be cancelled

		/// manually using `cancel_request`.

		///

		/// The dispatch origin for this call must match `T::ForceOrigin`.

		///

		/// - `target`: the account whose identity the judgement is upon. This must be an account

		///   with a registered identity.

		///

		/// Emits `IdentityKilled` if successful.

		#[pallet::call_index(10)]

		#[pallet::weight(T::WeightInfo::kill_identity(

			T::MaxRegistrars::get(),

			T::MaxSubAccounts::get(),

		))]

		pub fn kill_identity(

			origin: OriginFor<T>,

			target: AccountIdLookupOf<T>,

			// Figure out who we're meant to be clearing.

			// Grab their deposit (and check that they have one).

			// Slash their deposit from them.

		}

		/// Add the given account to the sender's subs.

		///

		/// Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated

		/// to the sender.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered

		/// sub identity of `sub`.

		#[pallet::call_index(11)]

		#[pallet::weight(T::WeightInfo::add_sub(T::MaxSubAccounts::get()))]

		pub fn add_sub(

			origin: OriginFor<T>,

			sub: AccountIdLookupOf<T>,

			data: Data,

			// Check if it's already claimed as sub-identity.

				);

		}

		/// Alter the associated name of the given sub-account.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered

		/// sub identity of `sub`.

		#[pallet::call_index(12)]

		#[pallet::weight(T::WeightInfo::rename_sub(T::MaxSubAccounts::get()))]

		pub fn rename_sub(

			origin: OriginFor<T>,

			sub: AccountIdLookupOf<T>,

			data: Data,

		}

		/// Remove the given account from the sender's subs.

		///

		/// Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated

		/// to the sender.

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered

		/// sub identity of `sub`.

		#[pallet::call_index(13)]

		#[pallet::weight(T::WeightInfo::remove_sub(T::MaxSubAccounts::get()))]

		}

		/// Remove the sender as a sub-account.

		///

		/// Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated

		/// to the sender (*not* the original depositor).

		///

		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered

		/// super-identity.

		///

		/// NOTE: This should not normally be used, but is provided in the case that the non-

		/// controller of an account is maliciously registered as a sub-account.

		#[pallet::call_index(14)]

		#[pallet::weight(T::WeightInfo::quit_sub(T::MaxSubAccounts::get()))]

		}

		/// Add an `AccountId` with permission to grant usernames with a given `suffix` appended.

		///

		/// The authority can grant up to `allocation` usernames. To top up their allocation, they

		/// should just issue (or request via governance) a new `add_username_authority` call.

		#[pallet::call_index(15)]

		#[pallet::weight(T::WeightInfo::add_username_authority())]

		pub fn add_username_authority(

			origin: OriginFor<T>,

			authority: AccountIdLookupOf<T>,

			suffix: Vec<u8>,

			allocation: u32,

			// We don't need to check the length because it gets checked when casting into a

			// `BoundedVec`.

			// The authority may already exist, but we don't need to check. They might be changing

			// their suffix or adding allocation, so we just want to overwrite whatever was there.

		}

		/// Remove `authority` from the username authorities.

		#[pallet::call_index(16)]

		#[pallet::weight(T::WeightInfo::remove_username_authority())]

		pub fn remove_username_authority(

			origin: OriginFor<T>,

			authority: AccountIdLookupOf<T>,

		}

		/// Set the username for `who`. Must be called by a username authority.

		///

		/// The authority must have an `allocation`. Users can either pre-sign their usernames or

		/// accept them later.

		///

		/// Usernames must:

		///   - Only contain lowercase ASCII characters or digits.

		///   - When combined with the suffix of the issuing authority be _less than_ the

		///     `MaxUsernameLength`.

		#[pallet::call_index(17)]

		#[pallet::weight(T::WeightInfo::set_username_for())]

		pub fn set_username_for(

			origin: OriginFor<T>,

			who: AccountIdLookupOf<T>,

			username: Vec<u8>,

			signature: Option<T::OffchainSignature>,

			// Ensure origin is a Username Authority and has an allocation. Decrement their

			// allocation by one.

			// Ensure that the username only contains allowed characters. We already know the suffix

			// does.

			// Concatenate the username with suffix and cast into a BoundedVec. Should be infallible

			// since we already ensured it is below the max length.

			// Usernames must be unique. Ensure it's not taken.

			);

			);

			// Insert or queue.

				// Account has pre-signed an authorization. Verify the signature provided and grant

				// the username directly.

		}

		/// Accept a given username that an `authority` granted. The call must include the full

		/// username, as in `username.suffix`.

		#[pallet::call_index(18)]

		#[pallet::weight(T::WeightInfo::accept_username())]

		pub fn accept_username(

			origin: OriginFor<T>,

			username: Username<T>,

		}

		/// Remove an expired username approval. The username was approved by an authority but never

		/// accepted by the user and must now be beyond its expiration. The call must include the

		/// full username, as in `username.suffix`.

		#[pallet::call_index(19)]

		#[pallet::weight(T::WeightInfo::remove_expired_approval())]

		pub fn remove_expired_approval(

			origin: OriginFor<T>,

			username: Username<T>,

			} else {

			}

		}

		/// Set a given username as the primary. The username should include the suffix.

		#[pallet::call_index(20)]

		#[pallet::weight(T::WeightInfo::set_primary_username())]

			// ensure `username` maps to `origin` (i.e. has already been set by an authority).

		}

		/// Remove a username that corresponds to an account with no identity. Exists when a user

		/// gets a username but then calls `clear_identity`.

		#[pallet::call_index(21)]

		#[pallet::weight(T::WeightInfo::remove_dangling_username())]

		pub fn remove_dangling_username(

			origin: OriginFor<T>,

			username: Username<T>,

		}

	}

}

impl<T: Config> Pallet<T> {

	/// Get the subs of an account.

	/// Calculate the deposit required for a number of `sub` accounts.

	/// Take the `current` deposit that `who` is holding, and update it to a `new` one.

	/// Check if the account has corresponding identity information by the identity field.

	/// Calculate the deposit required for an identity.

	/// Validate that a username conforms to allowed characters/format.

	///

	/// The function will validate the characters in `username` and that `length` (if `Some`)

	/// conforms to the limit. It is not expected to pass a fully formatted username here (i.e. one

	/// with any protocol-added characters included, such as a `.`). The suffix is also separately

	/// validated by this function to ensure the full username conforms.

		// Verify input length before allocating a Vec with the user's input. `<` instead of `<=`

		// because it needs one element for the point (`username` + `.` + `suffix`).

		// Usernames cannot be empty.

		// Username must be lowercase and alphanumeric.

		);

	/// Validate a signature. Supports signatures on raw `data` or `data` wrapped in HTML `<Bytes>`.

	/// A username has met all conditions. Insert the relevant storage items.

		// Check if they already have a primary. If so, leave it. If not, set it.

		// Likewise, check if they have an identity. If not, give them a minimal one.

			// User has an existing Identity and a primary username. Leave it.

			// User has an Identity but no primary. Set the new one as primary.

			// User does not have an existing Identity. Give them a fresh default one and set

			// their username as primary.

		};

		// Enter in identity map. Note: In the case that the user did not have a pre-existing

		// Identity, we have given them the storage item for free. If they ever call

		// `set_identity` with identity info, then they will need to place the normal identity

		// deposit.

	/// A username was granted by an authority, but must be accepted by `who`. Put the username

	/// into a queue for acceptance.