lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

stock_accounting.rs (11390B)


      1 use radroots_domain::stock::{
      2     HeldStockCategory, HeldStockLoss, ObligationBacking, PhysicalBalances, PoolBalances,
      3     StockError, StockTicks,
      4 };
      5 
      6 fn ticks(value: u64) -> StockTicks {
      7     StockTicks::new(value).unwrap()
      8 }
      9 
     10 fn total(physical: PhysicalBalances) -> u128 {
     11     [
     12         physical.available,
     13         physical.preparatory_hold,
     14         physical.committed_hold,
     15         physical.physical_quarantine,
     16         physical.consumed,
     17         physical.waste,
     18         physical.removed,
     19     ]
     20     .into_iter()
     21     .map(|quantity| u128::from(quantity.get()))
     22     .sum()
     23 }
     24 
     25 #[test]
     26 fn shortage_handover_and_residual_release_never_convert_deficits_into_physical_stock() {
     27     let physical = PoolBalances::new(
     28         ticks(100),
     29         PhysicalBalances {
     30             available: ticks(20),
     31             committed_hold: ticks(80),
     32             ..PhysicalBalances::ZERO
     33         },
     34     )
     35     .unwrap();
     36     let obligation = ObligationBacking::new(ticks(100), ticks(80), ticks(20)).unwrap();
     37     let depleted = physical
     38         .deplete_held(
     39             HeldStockCategory::Committed,
     40             HeldStockLoss::Spoilage,
     41             ticks(30),
     42         )
     43         .unwrap();
     44     let shortage = obligation.lose_backing(ticks(30)).unwrap();
     45     assert_eq!(shortage.remaining(), ticks(100));
     46     assert_eq!(shortage.backed(), ticks(50));
     47     assert_eq!(shortage.deficit(), ticks(50));
     48     assert_eq!(depleted.physical().waste, ticks(30));
     49     assert_eq!(depleted.physical().available, ticks(20));
     50 
     51     let delivered = depleted.consume_committed(ticks(20)).unwrap();
     52     let remaining = shortage.consume_backed(ticks(20)).unwrap();
     53     assert_eq!(remaining.remaining(), ticks(80));
     54     assert_eq!(remaining.backed(), ticks(30));
     55     assert_eq!(remaining.deficit(), ticks(50));
     56     assert_eq!(delivered.physical().consumed, ticks(20));
     57     assert_eq!(
     58         delivered.release_committed(ticks(80)),
     59         Err(StockError::Underflow)
     60     );
     61 
     62     let released = delivered.release_committed(ticks(30)).unwrap();
     63     let closed = remaining.release_residual(ticks(30), ticks(50)).unwrap();
     64     assert_eq!(closed.remaining(), StockTicks::ZERO);
     65     assert_eq!(closed.backed(), StockTicks::ZERO);
     66     assert_eq!(closed.deficit(), StockTicks::ZERO);
     67     assert_eq!(released.physical().available, ticks(50));
     68     assert_eq!(released.physical().consumed, ticks(20));
     69     assert_eq!(released.physical().waste, ticks(30));
     70     assert_eq!(total(released.physical()), 100);
     71     assert_eq!(physical.physical().committed_hold, ticks(80));
     72     assert_eq!(obligation.backed(), ticks(80));
     73 }
     74 
     75 #[test]
     76 fn quarantine_stays_nonspendable_until_an_explicit_proposed_resolution() {
     77     let original = PoolBalances::new(
     78         ticks(10),
     79         PhysicalBalances {
     80             preparatory_hold: ticks(4),
     81             committed_hold: ticks(6),
     82             ..PhysicalBalances::ZERO
     83         },
     84     )
     85     .unwrap();
     86     let held = original
     87         .quarantine_preparatory(ticks(4))
     88         .unwrap()
     89         .quarantine_committed(ticks(6))
     90         .unwrap();
     91     assert_eq!(held.physical().physical_quarantine, ticks(10));
     92     assert_eq!(held.physical().available, StockTicks::ZERO);
     93     assert_eq!(held.consume_committed(ticks(1)), Err(StockError::Underflow));
     94     assert_eq!(held.hold_available(ticks(1)), Err(StockError::Underflow));
     95 
     96     let reconciled = held
     97         .restore_quarantined(ticks(3))
     98         .unwrap()
     99         .consume_committed(ticks(3))
    100         .unwrap()
    101         .consume_quarantined(ticks(2))
    102         .unwrap()
    103         .release_quarantined(ticks(5))
    104         .unwrap();
    105     assert_eq!(reconciled.physical().available, ticks(5));
    106     assert_eq!(reconciled.physical().consumed, ticks(5));
    107     assert_eq!(reconciled.physical().physical_quarantine, StockTicks::ZERO);
    108     assert_eq!(total(reconciled.physical()), 10);
    109     assert_eq!(original.physical().committed_hold, ticks(6));
    110 }
    111 
    112 type Movement = fn(PoolBalances, StockTicks) -> Result<PoolBalances, StockError>;
    113 
    114 #[test]
    115 fn every_held_transition_conserves_lifetime_stock_and_refuses_zero_or_overdrawn_sources() {
    116     let movements: [(HeldStockCategory, Movement); 7] = [
    117         (
    118             HeldStockCategory::Committed,
    119             PoolBalances::release_committed,
    120         ),
    121         (
    122             HeldStockCategory::Committed,
    123             PoolBalances::consume_committed,
    124         ),
    125         (
    126             HeldStockCategory::Preparatory,
    127             PoolBalances::quarantine_preparatory,
    128         ),
    129         (
    130             HeldStockCategory::Committed,
    131             PoolBalances::quarantine_committed,
    132         ),
    133         (
    134             HeldStockCategory::Quarantined,
    135             PoolBalances::restore_quarantined,
    136         ),
    137         (
    138             HeldStockCategory::Quarantined,
    139             PoolBalances::release_quarantined,
    140         ),
    141         (
    142             HeldStockCategory::Quarantined,
    143             PoolBalances::consume_quarantined,
    144         ),
    145     ];
    146     for seed in 0..=16 {
    147         let physical = PhysicalBalances {
    148             available: ticks(seed),
    149             preparatory_hold: ticks(seed + 1),
    150             committed_hold: ticks(seed + 2),
    151             physical_quarantine: ticks(seed + 3),
    152             consumed: ticks(seed + 4),
    153             waste: ticks(seed + 5),
    154             removed: ticks(seed + 6),
    155         };
    156         let introduced = ticks(7 * seed + 21);
    157         let original = PoolBalances::new(introduced, physical).unwrap();
    158         for (category, movement) in movements {
    159             let source = match category {
    160                 HeldStockCategory::Preparatory => seed + 1,
    161                 HeldStockCategory::Committed => seed + 2,
    162                 HeldStockCategory::Quarantined => seed + 3,
    163             };
    164             assert_eq!(
    165                 movement(original, StockTicks::ZERO),
    166                 Err(StockError::ZeroMovement)
    167             );
    168             assert_eq!(
    169                 movement(original, ticks(source + 1)),
    170                 Err(StockError::Underflow)
    171             );
    172             for quantity in [ticks(1), ticks(source)] {
    173                 let changed = movement(original, quantity).unwrap();
    174                 assert_eq!(changed.introduced(), introduced);
    175                 assert_eq!(total(changed.physical()), u128::from(introduced.get()));
    176                 assert!(changed.physical().consumed >= physical.consumed);
    177                 assert_eq!(changed.physical().waste, physical.waste);
    178                 assert_eq!(changed.physical().removed, physical.removed);
    179             }
    180             for loss in [HeldStockLoss::Spoilage, HeldStockLoss::Removal] {
    181                 let changed = original
    182                     .deplete_held(category, loss, ticks(source))
    183                     .unwrap();
    184                 assert_eq!(changed.introduced(), introduced);
    185                 assert_eq!(total(changed.physical()), u128::from(introduced.get()));
    186                 assert_eq!(changed.physical().available, physical.available);
    187                 assert_eq!(changed.physical().consumed, physical.consumed);
    188                 assert_eq!(
    189                     original.deplete_held(category, loss, StockTicks::ZERO),
    190                     Err(StockError::ZeroMovement)
    191                 );
    192                 assert_eq!(
    193                     original.deplete_held(category, loss, ticks(source + 1)),
    194                     Err(StockError::Underflow)
    195                 );
    196             }
    197         }
    198         assert_eq!(original.physical(), physical);
    199     }
    200 }
    201 
    202 #[test]
    203 fn maximum_backing_can_be_consumed_released_or_lost_without_minting_capacity() {
    204     let original = PoolBalances::new(
    205         StockTicks::MAX,
    206         PhysicalBalances {
    207             committed_hold: StockTicks::MAX,
    208             ..PhysicalBalances::ZERO
    209         },
    210     )
    211     .unwrap();
    212     let consumed = original.consume_committed(StockTicks::MAX).unwrap();
    213     assert_eq!(consumed.physical().consumed, StockTicks::MAX);
    214     assert_eq!(consumed.physical().available, StockTicks::ZERO);
    215     assert_eq!(
    216         consumed.consume_committed(ticks(1)),
    217         Err(StockError::Underflow)
    218     );
    219     let released = original.release_committed(StockTicks::MAX).unwrap();
    220     assert_eq!(released.physical().available, StockTicks::MAX);
    221     assert_eq!(released.introduced(), StockTicks::MAX);
    222     let quarantined = original.quarantine_committed(StockTicks::MAX).unwrap();
    223     assert_eq!(
    224         quarantined.consume_quarantined(StockTicks::MAX).unwrap(),
    225         consumed
    226     );
    227     let lost = original
    228         .deplete_held(
    229             HeldStockCategory::Committed,
    230             HeldStockLoss::Removal,
    231             StockTicks::MAX,
    232         )
    233         .unwrap();
    234     assert_eq!(lost.physical().removed, StockTicks::MAX);
    235     assert_eq!(lost.physical().available, StockTicks::ZERO);
    236     assert_eq!(total(lost.physical()), u128::from(StockTicks::MAX.get()));
    237 }
    238 
    239 #[test]
    240 fn obligation_bounds_never_clamp_deficits_or_consume_unbacked_quantities() {
    241     assert_eq!(
    242         ObligationBacking::new(ticks(3), ticks(1), ticks(1)),
    243         Err(StockError::ObligationMismatch)
    244     );
    245     assert_eq!(
    246         ObligationBacking::new(StockTicks::MAX, StockTicks::MAX, ticks(1)),
    247         Err(StockError::OutOfRange)
    248     );
    249     let original =
    250         ObligationBacking::new(StockTicks::MAX, StockTicks::MAX, StockTicks::ZERO).unwrap();
    251     let lost = original.lose_backing(StockTicks::MAX).unwrap();
    252     assert_eq!(lost.remaining(), StockTicks::MAX);
    253     assert_eq!(lost.backed(), StockTicks::ZERO);
    254     assert_eq!(lost.deficit(), StockTicks::MAX);
    255     assert_eq!(lost.consume_backed(ticks(1)), Err(StockError::Underflow));
    256     assert_eq!(
    257         original.restore_backing(ticks(1)),
    258         Err(StockError::Underflow)
    259     );
    260     assert_eq!(lost.restore_backing(StockTicks::MAX).unwrap(), original);
    261     for proposal in [
    262         original.lose_backing(StockTicks::ZERO),
    263         lost.restore_backing(StockTicks::ZERO),
    264         original.consume_backed(StockTicks::ZERO),
    265         original.release_residual(StockTicks::ZERO, StockTicks::ZERO),
    266     ] {
    267         assert_eq!(proposal, Err(StockError::ZeroMovement));
    268     }
    269     let closed = lost
    270         .release_residual(StockTicks::ZERO, StockTicks::MAX)
    271         .unwrap();
    272     assert_eq!(closed.remaining(), StockTicks::ZERO);
    273     assert_eq!(
    274         closed.release_residual(StockTicks::ZERO, ticks(1)),
    275         Err(StockError::Underflow)
    276     );
    277     assert_eq!(
    278         format!("{original:?}"),
    279         "ObligationBacking(<private proposal>)"
    280     );
    281 }
    282 
    283 #[cfg(feature = "serde")]
    284 #[test]
    285 fn backing_codec_uses_closed_exact_strings_and_revalidates_the_obligation_equation() {
    286     let original = ObligationBacking::new(ticks(100), ticks(80), ticks(20)).unwrap();
    287     let raw = serde_json::to_string(&original).unwrap();
    288     assert_eq!(raw, r#"{"remaining":"100","backed":"80","deficit":"20"}"#);
    289     assert_eq!(
    290         serde_json::from_str::<ObligationBacking>(&raw).unwrap(),
    291         original
    292     );
    293     for bad in [
    294         r#"{"remaining":"100","backed":"80","deficit":"19"}"#,
    295         r#"{"remaining":"100","backed":80,"deficit":"20"}"#,
    296         r#"{"remaining":"100","backed":"080","deficit":"20"}"#,
    297         r#"{"remaining":"100","backed":"80","deficit":"20","available":"20"}"#,
    298         r#"{"remaining":"100","remaining":"100","backed":"80","deficit":"20"}"#,
    299         r#"{"remaining":"100","backed":"80"}"#,
    300         r#"["100","80","20"]"#,
    301     ] {
    302         assert!(
    303             serde_json::from_str::<ObligationBacking>(bad).is_err(),
    304             "{bad}"
    305         );
    306     }
    307 }