Struct DisclosureEvent 

pub struct DisclosureEvent {
    pub id: String,
    pub payload_commitment: PayloadCommitment,
    pub credential_id: String,
    pub recipient_did: String,
    pub acting_delegate_did: Option<String>,
    pub time_unix: u64,
    pub fingerprint: DisclosureFingerprint,
    pub kind: DisclosureKind,
}

One traced access / disclosure event — durable and tamper-evident (of the commons payload; a person revoking access, or a betrayer, cannot erase it). Says who was given/took access to what, when, under which credential, and by whom (including a delegate).

Fields

id: String

payload_commitment: PayloadCommitment

The commons payload disclosed (by commitment).

credential_id: String

Under which consent / transparency credential the disclosure occurred.

recipient_did: String

The party the disclosure was to / who holds the credential (e.g. the MP / minister).

acting_delegate_did: Option<String>

If a delegate actually acted under the credential (e.g. the MP’s staffer), their identifier. None = the recipient themselves acted. This is what makes a staff leak attributable.

time_unix: u64

fingerprint: DisclosureFingerprint

The per-recipient tracing fingerprint bound to this disclosure.

kind: DisclosureKind

Implementations

impl DisclosureEvent

pub fn accountable_actor(&self) -> &str

The actor accountable for this disclosure: the acting delegate (a staffer) if one acted, else the recipient (the authority) themselves. A leak traced to this event is attributable to this actor.

Trait Implementations

impl Clone for DisclosureEvent

fn clone(&self) -> DisclosureEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DisclosureEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DisclosureEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DisclosureEvent

fn eq(&self, other: &DisclosureEvent) -> 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 DisclosureEvent

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 DisclosureEvent

impl StructuralPartialEq for DisclosureEvent