Skip to main content

qualia_core_db/net/qdnf/economics/
mod.rs

1//! Typed resource quantities. Payment cannot enlarge consent or budgets.
2//!
3//! Finite commons recovery is owned by [`Obligation`]. [`RemainingTarget`] remains
4//! a compatibility snapshot of copied milli-units and is not the owner.
5
6pub 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    /// Adds an entry.
44    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/// Compatibility snapshot of a remaining amount. Not the obligation owner.
68/// Copied `milli_units` cannot settle; use [`Obligation`] + [`reserve_hold`].
69#[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    /// Always Denied. A copied RemainingTarget is not the owner (E17 / R17).
78    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}