qualia_core_db/net/qdnf/economics/
mod.rs1pub mod adapter;
7pub mod classify;
8pub mod consent;
9pub mod meters;
10pub mod obligation;
11pub mod recover;
12pub mod reserve;
13pub mod roles;
14pub mod router;
15pub mod settle;
16
17#[cfg(test)]
18mod concurrent;
19
20pub use adapter::*;
21pub use classify::*;
22pub use consent::*;
23pub use meters::*;
24pub use obligation::*;
25pub use recover::*;
26pub use reserve::*;
27pub use roles::*;
28pub use router::*;
29pub use settle::*;
30
31use crate::net::qdnf::authority::{CompensationClass, ObservationQuality, ResourceKind};
32use crate::net::qdnf::errors::QdnfError;
33
34#[repr(C)]
35#[derive(Clone, Copy, Debug, PartialEq, Eq)]
36pub struct Quantity {
37 pub kind: ResourceKind,
38 pub milli_units: u64,
39 pub quality: ObservationQuality,
40}
41
42impl Quantity {
43 pub fn add(self, other: Self) -> Result<Self, QdnfError> {
45 if self.kind != other.kind {
46 return Err(QdnfError::Malformed);
47 }
48 Ok(Self {
49 kind: self.kind,
50 milli_units: self
51 .milli_units
52 .checked_add(other.milli_units)
53 .ok_or(QdnfError::Range)?,
54 quality: match (self.quality, other.quality) {
55 (ObservationQuality::Unknown, _) | (_, ObservationQuality::Unknown) => {
56 ObservationQuality::Unknown
57 }
58 (ObservationQuality::Estimated, _) | (_, ObservationQuality::Estimated) => {
59 ObservationQuality::Estimated
60 }
61 _ => ObservationQuality::Measured,
62 },
63 })
64 }
65}
66
67#[repr(C)]
70#[derive(Clone, Copy, Debug, PartialEq, Eq)]
71pub struct RemainingTarget {
72 pub milli_units: u64,
73 pub class: CompensationClass,
74}
75
76impl RemainingTarget {
77 pub fn apply_payment(&self, amount: u64) -> Result<Self, QdnfError> {
79 let _ = (self, amount);
80 Err(QdnfError::Denied)
81 }
82}
83
84#[cfg(test)]
85mod tests {
86 use super::*;
87
88 #[test]
89 fn zero_target_refuses_recovery() {
90 let t = RemainingTarget {
91 milli_units: 0,
92 class: CompensationClass::Humanitarian,
93 };
94 assert_eq!(t.apply_payment(1), Err(QdnfError::Denied));
95 }
96
97 #[test]
98 fn copied_remaining_target_is_not_owner() {
99 let t = RemainingTarget {
100 milli_units: 100,
101 class: CompensationClass::CorporateDelegated,
102 };
103 let copy = t;
104 assert_eq!(t.apply_payment(1), Err(QdnfError::Denied));
105 assert_eq!(copy.apply_payment(t.milli_units), Err(QdnfError::Denied));
106 assert_eq!(copy.milli_units, 100);
107 }
108
109 #[test]
110 fn energy_and_time_do_not_add() {
111 let e = Quantity {
112 kind: ResourceKind::EnergyJoules,
113 milli_units: 1,
114 quality: ObservationQuality::Measured,
115 };
116 let t = Quantity {
117 kind: ResourceKind::TimeSeconds,
118 milli_units: 1,
119 quality: ObservationQuality::Measured,
120 };
121 assert_eq!(e.add(t), Err(QdnfError::Malformed));
122 }
123
124 #[test]
125 fn fulfilment_cannot_bypass_bilateral_identity_lock() {
126 use crate::{
127 evaluate_permissive_runtime_gate, MASK_AUTHENTICATED_NATURAL_PERSON,
128 MASK_BILATERAL_IDENTITY_LOCKED, MASK_WORK_OBLIGATION_SATISFIED,
129 };
130 let entry = MASK_BILATERAL_IDENTITY_LOCKED | MASK_WORK_OBLIGATION_SATISFIED;
131 assert!(
132 !evaluate_permissive_runtime_gate(entry, 0),
133 "work-obligation satisfied must not open bilateral-locked data"
134 );
135 assert!(evaluate_permissive_runtime_gate(
136 entry,
137 MASK_AUTHENTICATED_NATURAL_PERSON
138 ));
139 assert!(evaluate_permissive_runtime_gate(
140 MASK_WORK_OBLIGATION_SATISFIED,
141 0
142 ));
143 }
144}