Struct pallet_identity::legacy::IdentityInfo

pub struct IdentityInfo<FieldLimit: Get<u32>> {
    pub additional: BoundedVec<(Data, Data), FieldLimit>,
    pub display: Data,
    pub legal: Data,
    pub web: Data,
    pub riot: Data,
    pub email: Data,
    pub pgp_fingerprint: Option<[u8; 20]>,
    pub image: Data,
    pub twitter: Data,
}

Information concerning the identity of the controller of an account.

NOTE: This should be stored at the end of the storage item to facilitate the addition of extra fields in a backwards compatible way through a specialized Decode impl.

Fields

additional: BoundedVec<(Data, Data), FieldLimit>

Additional fields of the identity that are not catered for with the struct’s explicit fields.

display: Data

A reasonable display name for the controller of the account. This should be whatever it is that it is typically known as and should not be confusable with other entities, given reasonable context.

Stored as UTF-8.

legal: Data

The full legal name in the local jurisdiction of the entity. This might be a bit long-winded.

Stored as UTF-8.

web: Data

A representative website held by the controller of the account.

NOTE: https:// is automatically prepended.

Stored as UTF-8.

riot: Data

The Riot/Matrix handle held by the controller of the account.

Stored as UTF-8.

email: Data

The email address of the controller of the account.

Stored as UTF-8.

pgp_fingerprint: Option<[u8; 20]>

The PGP/GPG public key of the controller of the account.

image: Data

A graphic image representing the controller of the account. Should be a company, organization or project logo or a headshot in the case of a human.

twitter: Data

The Twitter identity. The leading @ character may be elided.

Trait Implementations

impl<FieldLimit: Get<u32>> Clone for IdentityInfo<FieldLimit>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<FieldLimit: Get<u32>> Debug for IdentityInfo<FieldLimit>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<FieldLimit: Get<u32>> Decode for IdentityInfo<FieldLimit>

where BoundedVec<(Data, Data), FieldLimit>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<FieldLimit: Get<u32>> Default for IdentityInfo<FieldLimit>

fn default() -> Self

Returns the “default value” for a type.

impl<FieldLimit: Get<u32>> Encode for IdentityInfo<FieldLimit>

where BoundedVec<(Data, Data), FieldLimit>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<FieldLimit: Get<u32> + 'static> IdentityInformationProvider for IdentityInfo<FieldLimit>

type FieldsIdentifier = u64

Type capable of holding information on which identity fields are set.

fn has_identity(&self, fields: Self::FieldsIdentifier) -> bool

Check if an identity registered information for some given fields.

fn create_identity_info() -> Self

Create a basic instance of the identity information.

fn all_fields() -> Self::FieldsIdentifier

The identity information representation for all identity fields enabled.

impl<FieldLimit: Get<u32>> MaxEncodedLen for IdentityInfo<FieldLimit>

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<FieldLimit: Get<u32>> PartialEq for IdentityInfo<FieldLimit>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<FieldLimit> TypeInfo for IdentityInfo<FieldLimit>

where BoundedVec<(Data, Data), FieldLimit>: TypeInfo + 'static, FieldLimit: Get<u32> + 'static,

type Identity = IdentityInfo<FieldLimit>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<FieldLimit: Get<u32>> EncodeLike for IdentityInfo<FieldLimit>

where BoundedVec<(Data, Data), FieldLimit>: Encode,

impl<FieldLimit: Get<u32>> Eq for IdentityInfo<FieldLimit>