liminal-protocol 0.2.1

Shared participant-lifecycle protocol types for liminal
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::{
    lifecycle::{
        OrderClaims, OrderHigh, OrderLedger, RetainedCausalRecord, SequenceClaims, SequenceLedger,
    },
    wire::TransactionOrder,
};

pub(super) fn enrollment_sequence(current: SequenceLedger, high: u64) -> Option<SequenceLedger> {
    let claims = current.claims();
    SequenceLedger::try_new(
        high,
        SequenceClaims::new(
            claims.live_members().checked_add(1)?,
            claims.binding_terminals().checked_add(1)?,
            claims.markers(),
            claims.recovery(),
        ),
    )
    .ok()
}

pub(super) fn detached_attach_sequence(
    current: SequenceLedger,
    high: u64,
) -> Option<SequenceLedger> {
    let claims = current.claims();
    SequenceLedger::try_new(
        high,
        SequenceClaims::new(
            claims.live_members(),
            claims.binding_terminals().checked_add(1)?,
            claims.markers(),
            claims.recovery(),
        ),
    )
    .ok()
}

pub(super) fn superseding_attach_sequence(
    current: SequenceLedger,
    rows: &[RetainedCausalRecord],
) -> Option<SequenceLedger> {
    let high = rows.last()?.delivery_seq;
    let first = rows.first()?.delivery_seq;
    (first == current.high_watermark().checked_add(1)? && high == first.checked_add(1)?)
        .then(|| SequenceLedger::try_new(high, current.claims()).ok())
        .flatten()
}

pub(super) fn detach_sequence(current: SequenceLedger, high: u64) -> Option<SequenceLedger> {
    let claims = current.claims();
    SequenceLedger::try_new(
        high,
        SequenceClaims::new(
            claims.live_members(),
            claims.binding_terminals().checked_sub(1)?,
            claims.markers(),
            claims.recovery(),
        ),
    )
    .ok()
}

pub(super) fn enrollment_order(
    current: OrderLedger,
    major: TransactionOrder,
) -> Option<OrderLedger> {
    let claims = current.claims();
    next_order(
        current,
        major,
        OrderClaims::new(
            claims.active_binding_terminals().checked_add(1)?,
            claims.membership_exits().checked_add(1)?,
            claims.recovery_operation(),
            claims.recovery_replacement_terminal(),
        )
        .ok()?,
    )
}

pub(super) fn detached_attach_order(
    current: OrderLedger,
    major: TransactionOrder,
) -> Option<OrderLedger> {
    let claims = current.claims();
    next_order(
        current,
        major,
        OrderClaims::new(
            claims.active_binding_terminals().checked_add(1)?,
            claims.membership_exits(),
            claims.recovery_operation(),
            claims.recovery_replacement_terminal(),
        )
        .ok()?,
    )
}

pub(super) fn superseding_attach_order(
    current: OrderLedger,
    major: TransactionOrder,
) -> Option<OrderLedger> {
    next_order(current, major, current.claims())
}

pub(super) fn detach_order(current: OrderLedger, major: TransactionOrder) -> Option<OrderLedger> {
    let claims = current.claims();
    next_order(
        current,
        major,
        OrderClaims::new(
            claims.active_binding_terminals().checked_sub(1)?,
            claims.membership_exits(),
            claims.recovery_operation(),
            claims.recovery_replacement_terminal(),
        )
        .ok()?,
    )
}

fn next_order(
    current: OrderLedger,
    major: TransactionOrder,
    claims: OrderClaims,
) -> Option<OrderLedger> {
    let expected = match current.high() {
        OrderHigh::Empty => 0,
        OrderHigh::Allocated(high) => high.checked_add(1)?,
    };
    (major == expected)
        .then(|| OrderLedger::try_new(OrderHigh::Allocated(major), claims).ok())
        .flatten()
}