qualia_core_db/net/qdnf/economics/
recover.rs1use 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#[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
22pub 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#[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}