qualia_core_db/net/peer/fabric/
intent.rs1use crate::net::peer::connectivity::policy::Disclosure;
4use crate::net::peer::runtime::ResourceBudget;
5use crate::q_hash;
6
7pub type PeerId = [u8; 32];
8
9#[repr(u8)]
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11pub enum PurposeClass {
12 Ordinary = 1,
13 Clinical = 2,
14 Infrastructure = 3,
15}
16
17#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub struct Purpose {
19 pub iri_hash: u64,
20 pub class: PurposeClass,
21}
22
23impl Purpose {
24 pub const fn ordinary() -> Self {
26 Self {
27 iri_hash: q_hash("q42:purpose/ordinary"),
28 class: PurposeClass::Ordinary,
29 }
30 }
31
32 pub const fn clinical() -> Self {
34 Self {
35 iri_hash: q_hash("q42:purpose/clinical"),
36 class: PurposeClass::Clinical,
37 }
38 }
39}
40
41#[derive(Debug, Clone, Copy, PartialEq, Eq)]
43pub struct ProtectionPolicy {
44 pub disclosure: Disclosure,
45 pub require_e2e_session: bool,
46 pub public_dht: bool,
47}
48
49impl ProtectionPolicy {
50 pub const ORDINARY: Self = Self {
51 disclosure: Disclosure::DirectPermitted,
52 require_e2e_session: true,
53 public_dht: false,
54 };
55
56 pub const RELAY_ONLY: Self = Self {
57 disclosure: Disclosure::ApprovedRelaysOnly,
58 require_e2e_session: true,
59 public_dht: false,
60 };
61
62 pub const ISOLATED: Self = Self {
63 disclosure: Disclosure::Isolated,
64 require_e2e_session: true,
65 public_dht: false,
66 };
67}
68
69#[derive(Debug, Clone, Copy, PartialEq, Eq)]
70pub struct ConnectionIntent {
71 pub peer: PeerId,
72 pub purpose: Purpose,
73 pub authority: u64,
74 pub protection: ProtectionPolicy,
75 pub deadline_ms: u64,
76 pub budget: ResourceBudget,
77 pub created_ms: u64,
78}
79
80impl ConnectionIntent {
81 pub const fn new(
83 peer: PeerId,
84 purpose: Purpose,
85 protection: ProtectionPolicy,
86 budget: ResourceBudget,
87 now_ms: u64,
88 deadline_ms: u64,
89 ) -> Self {
90 Self {
91 peer,
92 purpose,
93 authority: 0,
94 protection,
95 deadline_ms,
96 budget,
97 created_ms: now_ms,
98 }
99 }
100
101 pub const fn expired(&self, now_ms: u64) -> bool {
103 now_ms >= self.deadline_ms
104 }
105}
106
107#[cfg(test)]
108mod tests {
109 use super::*;
110
111 #[test]
112 fn ordinary_does_not_enable_public_dht() {
113 assert!(!ProtectionPolicy::ORDINARY.public_dht);
114 assert!(!ProtectionPolicy::RELAY_ONLY.public_dht);
115 assert_ne!(Purpose::ordinary().iri_hash, Purpose::clinical().iri_hash);
116 }
117}