Skip to main content

qualia_core_db/net/qdnf/economics/
recover.rs

1//! Provider failure, withdrawal and incomplete work (E18.5).
2//!
3//! Reconcile without a second payout. Protected content is never held hostage.
4
5use crate::net::qdnf::errors::QdnfError;
6use crate::net::qdnf::types::StrongDigest;
7
8use super::obligation::{Obligation, OpState};
9use super::reserve::cancel;
10use super::settle::finalise;
11
12/// Provider delivery outcome for one operation.
13#[repr(u8)]
14#[derive(Clone, Copy, Debug, PartialEq, Eq)]
15pub enum ProviderOutcome {
16    Delivered = 1,
17    Incomplete = 2,
18    Withdrawn = 3,
19    Disputed = 4,
20}
21
22/// Reconcile one operation. Duplicate delivered finalise is idempotent.
23///
24/// Incomplete, withdrawn and disputed holds release without paying. Already
25/// settled amounts are not paid again; chargeback stays [`super::settle::reverse`].
26pub fn reconcile_provider(
27    ob: &mut Obligation,
28    op_id: StrongDigest,
29    outcome: ProviderOutcome,
30) -> Result<(), QdnfError> {
31    if op_id.is_zero() {
32        return Err(QdnfError::Malformed);
33    }
34    let i = ob.find_op(op_id).ok_or(QdnfError::Incomplete)?;
35    match (ob.ops[i].state, outcome) {
36        (OpState::Finalised, ProviderOutcome::Delivered) => Ok(()),
37        (OpState::Held, ProviderOutcome::Delivered) => {
38            let amt = ob.ops[i].amount;
39            finalise(ob, amt, op_id, false)
40        }
41        (OpState::Held, ProviderOutcome::Incomplete)
42        | (OpState::Held, ProviderOutcome::Withdrawn)
43        | (OpState::Held, ProviderOutcome::Disputed) => cancel(ob, op_id),
44        (OpState::Finalised, ProviderOutcome::Incomplete)
45        | (OpState::Finalised, ProviderOutcome::Withdrawn)
46        | (OpState::Finalised, ProviderOutcome::Disputed) => Ok(()),
47        (OpState::Cancelled | OpState::Reversed, ProviderOutcome::Delivered) => {
48            Err(QdnfError::Denied)
49        }
50        (OpState::Cancelled | OpState::Reversed, _) => Ok(()),
51        (OpState::Empty, _) => Err(QdnfError::Incomplete),
52    }
53}
54
55/// Provider failure never withholds protected content pending payment.
56#[inline]
57pub fn holds_protected_content_hostage() -> bool {
58    false
59}
60
61#[cfg(test)]
62mod tests {
63    use super::*;
64    use crate::crypto::network::digest::sha384;
65    use crate::net::qdnf::economics::classify::ActingClass;
66    use crate::net::qdnf::economics::reserve::reserve_hold;
67    use crate::net::qdnf::economics::settle::finalise as settle_finalise;
68
69    fn open(t: u64) -> Obligation {
70        Obligation::open(sha384(b"e18-recover-ob"), t).unwrap()
71    }
72
73    fn op(tag: u8) -> StrongDigest {
74        sha384(&[tag])
75    }
76
77    #[test]
78    fn incomplete_work_does_not_pay() {
79        let mut ob = open(8);
80        reserve_hold(&mut ob, 5, ActingClass::Corporate, op(1)).unwrap();
81        reconcile_provider(&mut ob, op(1), ProviderOutcome::Incomplete).unwrap();
82        assert_eq!(ob.settled_s, 0);
83        assert_eq!(ob.holds_h, 0);
84        assert!(!ob.fulfilled);
85        assert!(!holds_protected_content_hostage());
86    }
87
88    #[test]
89    fn withdrawal_and_dispute_do_not_duplicate_payout() {
90        let mut ob = open(8);
91        reserve_hold(&mut ob, 4, ActingClass::Corporate, op(2)).unwrap();
92        settle_finalise(&mut ob, 4, op(2), false).unwrap();
93        assert_eq!(ob.settled_s, 4);
94        reconcile_provider(&mut ob, op(2), ProviderOutcome::Delivered).unwrap();
95        reconcile_provider(&mut ob, op(2), ProviderOutcome::Withdrawn).unwrap();
96        reconcile_provider(&mut ob, op(2), ProviderOutcome::Disputed).unwrap();
97        assert_eq!(ob.settled_s, 4);
98        assert!(!holds_protected_content_hostage());
99        reserve_hold(&mut ob, 3, ActingClass::Corporate, op(3)).unwrap();
100        reconcile_provider(&mut ob, op(3), ProviderOutcome::Withdrawn).unwrap();
101        assert_eq!(ob.settled_s, 4);
102        assert_eq!(ob.holds_h, 0);
103        assert_eq!(
104            reconcile_provider(&mut ob, op(2), ProviderOutcome::Delivered),
105            Ok(())
106        );
107        assert_eq!(ob.settled_s, 4);
108    }
109}