Struct ConsentCredential 

pub struct ConsentCredential {
    pub id: String,
    pub subject_did: String,
    pub agent_did: String,
    pub scope: String,
    pub purpose: String,
    pub payload_commitment: PayloadCommitment,
    pub granted_unix: u64,
    pub expiry_unix: Option<u64>,
    pub revoked_unix: Option<u64>,
    pub authority: CredentialAuthority,
    pub authorization: Authorization,
    /* private fields */
}

A consent credential — grants an agent scoped access to an encrypted payload; revocable, with the revocation crypto-enforced (the wrapped key is destroyed). Its authority may be self-consent, a court, or another authority (CredentialAuthority); its exercise may require multi-sig (Authorization).

Fields

id: String

subject_did: String

The person granting consent (the data-subject).

agent_did: String

The granted agent (e.g. the social worker — a human, by identifier).

scope: String

What is granted, purpose-bound (minimal-disclosure scope).

purpose: String

payload_commitment: PayloadCommitment

A commitment to the granted payload — durable, binds the conduct trail.

granted_unix: u64

expiry_unix: Option<u64>

Optional expiry — access ceases at/after this time even without an explicit revoke.

revoked_unix: Option<u64>

Set on revoke — the moment after which the payload is unavailable.

authority: CredentialAuthority

Where this credential’s authority derives from (subject / court / authority).

authorization: Authorization

How it may be exercised (alone, or multi-sig requiring party instigation + threshold).

Implementations

impl ConsentCredential

pub fn grant( id: impl Into<String>, subject_did: impl Into<String>, agent_did: impl Into<String>, scope: impl Into<String>, purpose: impl Into<String>, payload_commitment: PayloadCommitment, wrapped_key: Vec<u8>, granted_unix: u64, expiry_unix: Option<u64>, ) -> Self

Grant a credential. wrapped_key is the data key wrapped for the agent (from the vault’s envelope encryption) — the thing revocation destroys.

pub fn with_authority(self, authority: CredentialAuthority) -> Self

Set the credential’s authority basis (a court order / another authority). Builder-style.

pub fn requiring_multisig(self, parties: Vec<Party>, threshold: usize) -> Self

Require multi-sig exercise: instigation by a participating party + threshold party signatures. Builder-style. This is what makes the credential unable to act without a participating party.

pub fn is_active(&self, now_unix: u64) -> bool

Whether the credential is currently active (not revoked, not past expiry).

pub fn revoke(&mut self, now_unix: u64)

Revoke the credential — crypto-enforced: records the moment and destroys the wrapped key, so the payload can no longer be decrypted (it returns to the person). Idempotent.

pub fn payload_key(&self, now_unix: u64) -> Option<&[u8]>

The wrapped data key iff access is currently permitted — None once revoked or expired. A None here is “the payload is unavailable to the agent”: with no key there is nothing to decrypt with.

pub fn payload_accessible(&self, now_unix: u64) -> bool

Whether the encrypted payload is technically accessible right now (active + key present) — ignoring any multi-sig requirement. For a multi-sig credential use can_exercise / exercise, which enforce party-instigation + threshold.

pub fn can_exercise(&self, req: &ExerciseRequest, now_unix: u64) -> bool

Whether a specific exercise is permitted: the credential is active and the request satisfies the Authorization (for multi-sig: instigated by a participating party + threshold signatures). This is the gate that stops an authority acting unilaterally.

pub fn exercise(&self, req: &ExerciseRequest, now_unix: u64) -> Option<&[u8]>

The wrapped data key iff this exercise is authorised (active + authorization satisfied). The authorization-aware counterpart to payload_key: a multi-sig credential yields a key only when a participating party instigated it and the threshold has signed.

Trait Implementations

impl Clone for ConsentCredential

fn clone(&self) -> ConsentCredential

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConsentCredential

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConsentCredential

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ConsentCredential

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ConsentCredential

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ConsentCredential

impl StructuralPartialEq for ConsentCredential