liminal-protocol 0.3.2

Shared participant-lifecycle protocol types for liminal
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use super::{
    AttachAttemptToken, ClientDiscriminant, ConversationId, DeliverySeq, DetachAttemptToken,
    EnrollmentToken, Generation, LeaveAttemptToken, ParticipantId, RecordAdmissionAttemptToken,
};

/// Enrollment response common envelope.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct EnrollmentEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Enrollment token from the request.
    pub enrollment_token: EnrollmentToken,
}

/// Credential-attach response common envelope; the secret is deliberately absent.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AttachEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Participant from the request.
    pub participant_id: ParticipantId,
    /// Presented generation.
    pub capability_generation: Generation,
    /// Attach token from the request.
    pub attach_attempt_token: AttachAttemptToken,
    /// Presented marker option.
    pub accept_marker_delivery_seq: Option<DeliverySeq>,
}

/// Detach response common envelope.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DetachEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Participant from the request.
    pub participant_id: ParticipantId,
    /// Presented generation.
    pub capability_generation: Generation,
    /// Detach token from the request.
    pub detach_attempt_token: DetachAttemptToken,
}

/// Continuous-ack response common envelope.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ParticipantAckEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Participant from the request.
    pub participant_id: ParticipantId,
    /// Presented generation.
    pub capability_generation: Generation,
    /// Requested cumulative boundary.
    pub through_seq: DeliverySeq,
}

/// Leave response common envelope; the secret is deliberately absent.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LeaveEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Participant from the request.
    pub participant_id: ParticipantId,
    /// Presented generation.
    pub capability_generation: Generation,
    /// Leave token from the request.
    pub leave_attempt_token: LeaveAttemptToken,
}

/// Marker-ack response common envelope.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MarkerAckEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Participant from the request.
    pub participant_id: ParticipantId,
    /// Presented generation.
    pub capability_generation: Generation,
    /// Requested marker sequence.
    pub marker_delivery_seq: DeliverySeq,
}

/// Ordinary-admission response common envelope; payload is deliberately absent.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RecordAdmissionEnvelope {
    /// Conversation from the request.
    pub conversation_id: ConversationId,
    /// Participant from the request.
    pub participant_id: ParticipantId,
    /// Presented generation.
    pub capability_generation: Generation,
    /// Client-selected request-attempt identity echoed by every terminal response.
    pub record_admission_attempt_token: RecordAdmissionAttemptToken,
}

/// Exact operation-specific response envelope for requests `0x0001..=0x0007`.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ResponseEnvelope {
    /// Enrollment envelope.
    Enrollment(EnrollmentEnvelope),
    /// Credential-attach envelope.
    CredentialAttach(AttachEnvelope),
    /// Detach envelope.
    Detach(DetachEnvelope),
    /// Continuous-ack envelope.
    ParticipantAck(ParticipantAckEnvelope),
    /// Leave envelope.
    Leave(LeaveEnvelope),
    /// Marker-ack envelope.
    MarkerAck(MarkerAckEnvelope),
    /// Ordinary-admission envelope.
    RecordAdmission(RecordAdmissionEnvelope),
}

impl ResponseEnvelope {
    /// Returns the structural `originating_request` selector.
    #[must_use]
    pub const fn originating_request(&self) -> ClientDiscriminant {
        match self {
            Self::Enrollment(_) => ClientDiscriminant::EnrollmentRequest,
            Self::CredentialAttach(_) => ClientDiscriminant::CredentialAttachRequest,
            Self::Detach(_) => ClientDiscriminant::DetachRequest,
            Self::ParticipantAck(_) => ClientDiscriminant::ParticipantAck,
            Self::Leave(_) => ClientDiscriminant::LeaveRequest,
            Self::MarkerAck(_) => ClientDiscriminant::MarkerAck,
            Self::RecordAdmission(_) => ClientDiscriminant::RecordAdmission,
        }
    }
}