Struct concordium_std::Policy

pub struct Policy<Attributes> {
    pub identity_provider: u32,
    pub created_at: Timestamp,
    pub valid_to: Timestamp,
    pub items: Attributes,
}

Policy on the credential of the account.

This is one of the key features of the Concordium blockchain. Each account on the chain is backed by an identity. The policy is verified and signed by the identity provider before an account can be created on the chain.

The type is parameterized by the choice of Attributes. These are either borrowed or owned, in the form of an iterator over key-value pairs or a vector of such. This flexibility is needed so that attributes can be accessed efficiently, as well as constructed conveniently for testing.

Fields

identity_provider: u32

Identity of the identity provider who signed the identity object that this policy is derived from.

created_at: Timestamp

Timestamp at the beginning of the month when the identity object backing this policy was created. This timestamp has very coarse granularity in order for the identity provider to not be able to link identities they have created with accounts that users created on the chain. as a timestamp (which has millisecond granularity) in order to make it easier to compare with, e.g., slot_time.

valid_to: Timestamp

Beginning of the month where the identity is no longer valid.

items: Attributes

List of attributes, in ascending order of the tag.

Trait Implementations

impl<Attributes> Clone for Policy<Attributes>where
Attributes: Clone,

fn clone(&self) -> Policy<Attributes>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Attributes> Debug for Policy<Attributes>where
Attributes: Debug,

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

Formats the value using the given formatter.

impl Deserial for Policy<Vec<(AttributeTag, AttributeValue), Global>>

fn deserial<R>(
source: &mut R
) -> Result<Policy<Vec<(AttributeTag, AttributeValue), Global>>, ParseError>where
R: Read,

Attempt to read a structure from a given source, failing if an error occurs during deserialization or reading.

impl HasPolicy for Policy<AttributesCursor>

type Iterator = PolicyAttributesIter

fn identity_provider(&self) -> IdentityProvider

Identity provider who signed the identity object the credential is derived from.

fn created_at(&self) -> Timestamp

Beginning of the month in milliseconds since unix epoch when the credential was created.

fn valid_to(&self) -> Timestamp

Beginning of the month where the credential is no longer valid, in milliseconds since unix epoch.

fn next_item(&mut self, buf: &mut [u8; 31]) -> Option<(AttributeTag, u8)>

Get the next attribute, storing it in the provided buffer. The return value, if Some, is a pair of an attribute tag, and the length, n of the attribute value. In this case, the attribute value is written in the first n bytes of the provided buffer. The rest of the buffer is unchanged.

fn attributes(&self) -> Self::Iterator

Get an iterator over all the attributes of the policy.

impl Serial for Policy<Vec<(AttributeTag, AttributeValue), Global>>

fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err>where
W: Write,

Attempt to write the structure into the provided writer, failing if only part of the structure could be written.