Struct ockam_entity::ProfileState

pub struct ProfileState { /* fields omitted */ }

Profile implementation

Implementations

impl ProfileState

pub fn new(
    identifier: ProfileIdentifier,
    change_events: Changes,
    contacts: Contacts,
    vault: VaultSync,
    rng: impl RngCore + CryptoRng + Clone
) -> Self

Profile constructor

pub fn vault(&self) -> VaultSync

Return clone of Vault

pub fn get_root_secret(&mut self) -> Result<Secret>

impl ProfileState

pub fn create_key_static(
    prev_id: EventIdentifier,
    key_attributes: KeyAttributes,
    attributes: ProfileEventAttributes,
    root_key: Option<&Secret>,
    vault: &mut VaultSync
) -> Result<ProfileChangeEvent>

Create a new key

Trait Implementations

impl Clone for ProfileState

fn clone(&self) -> ProfileState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CredentialHolder for ProfileState

fn accept_credential_offer(
    &mut self,
    offer: &CredentialOffer,
    signing_public_key: SigningPublicKey
) -> Result<(CredentialRequest, CredentialFragment1)>

Accepts a credential offer from an issuer

fn combine_credential_fragments(
    &mut self,
    credential_fragment1: CredentialFragment1,
    credential_fragment2: CredentialFragment2
) -> Result<Credential>

Combine credential fragments to yield a completed credential

fn is_valid_credential(
    &mut self,
    credential: &Credential,
    verifier_key: SigningPublicKey
) -> Result<bool>

Check a credential to make sure its valid

fn present_credentials(
    &mut self,
    credential: &[Credential],
    presentation_manifests: &[PresentationManifest],
    proof_request_id: ProofRequestId
) -> Result<Vec<CredentialPresentation>>

Given a list of credentials, and a list of manifests generates a zero-knowledge presentation. Each credential maps to a presentation manifest

impl CredentialIssuer for ProfileState

fn get_signing_key(&mut self) -> Result<BlsSecretKey>

Return the signing key associated with this CredentialIssuer

fn get_signing_public_key(&mut self) -> Result<SigningPublicKey>

Return the public key

fn create_offer(&mut self, schema: &CredentialSchema) -> Result<CredentialOffer>

Create a credential offer

fn create_proof_of_possession(&mut self) -> Result<ProofBytes>

Create a proof of possession for this issuers signing key

fn sign_credential(
    &mut self,
    schema: &CredentialSchema,
    attributes: &[CredentialAttribute]
) -> Result<Credential>

Sign the claims into the credential

fn sign_credential_request(
    &mut self,
    request: &CredentialRequest,
    schema: &CredentialSchema,
    attributes: &[(String, CredentialAttribute)],
    offer_id: OfferId
) -> Result<CredentialFragment2>

Sign a credential request where certain claims have already been committed and signs the remaining claims

impl CredentialVerifier for ProfileState

fn create_proof_request_id(&mut self) -> Result<ProofRequestId>

Create a unique proof request id so the holder must create a fresh proof

fn verify_proof_of_possession(
    &mut self,
    issuer_vk: [u8; 96],
    proof: [u8; 48]
) -> Result<bool>

Verify a proof of possession

fn verify_credential_presentations(
    &mut self,
    presentations: &[CredentialPresentation],
    presentation_manifests: &[PresentationManifest],
    proof_request_id: [u8; 32]
) -> Result<bool>

Check if the credential presentations are valid

impl Identity for ProfileState

fn get_profile_secret_key(&self) -> Result<Secret>

Get Secret key. Key is uniquely identified by label in KeyAttributes

fn create_auth_proof<S: AsRef<[u8]>>(
    &mut self,
    channel_state: S
) -> Result<AuthenticationProof>

Generate Proof of possession of Profile. channel_state should be tied to channel’s cryptographical material (e.g. h value for Noise XX)

fn verify_auth_proof<S: AsRef<[u8]>, P: AsRef<[u8]>>(
    &mut self,
    channel_state: S,
    responder_contact_id: &ProfileIdentifier,
    proof: P
) -> Result<bool>

Verify Proof of possession of Profile with given ProfileIdentifier. channel_state should be tied to channel’s cryptographical material (e.g. h value for Noise XX)

fn verify_changes(&mut self) -> Result<bool>

Verify whole event chain of current Profile

fn identifier(&self) -> Result<ProfileIdentifier>

Return unique [Profile] identifier, which is equal to sha256 of the root public key

fn create_key<S: Into<String>>(&mut self, label: S) -> Result<()>

Create new key.

fn rotate_profile_key(&mut self) -> Result<()>

Rotate existing key.

fn get_secret_key<S: Into<String>>(&self, label: S) -> Result<Secret>

Get Secret key.

fn get_profile_public_key(&self) -> Result<PublicKey>

Get PublicKey.

fn get_public_key<S: Into<String>>(&self, label: S) -> Result<PublicKey>

Get PublicKey.

fn add_change(&mut self, change_event: ProfileChangeEvent) -> Result<()>

Add a change event.

fn get_changes(&self) -> Result<Changes>

Return change history chain

fn get_contacts(&self) -> Result<Vec<Contact>>

Return all known to this profile Contacts

fn as_contact(&mut self) -> Result<Contact>

Convert [Profile] to Contact

fn get_contact(&mut self, id: &ProfileIdentifier) -> Result<Option<Contact>>

Return Contact with given ProfileIdentifier

fn verify_contact<C: Into<Contact>>(&mut self, contact: C) -> Result<bool>

Verify cryptographically whole event chain. Also verify sequence correctness

fn verify_and_add_contact<C: Into<Contact>>(
    &mut self,
    contact: C
) -> Result<bool>

Verify and add new Contact to [Profile]’s Contact list

fn verify_and_update_contact<C: AsRef<[ProfileChangeEvent]>>(
    &mut self,
    contact_id: &ProfileIdentifier,
    change_events: C
) -> Result<bool>

Verify and update known Contact with new ProfileChangeEvents