canic-host 0.111.0

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
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

//! Interpret exact funding facts, never retryability or incidental reservation bookkeeping.

#[cfg(test)]
mod tests;

use crate::fleet_ensure::view::release::funding::{
    RecordedRefillCycles, ReleaseRefillDisposition, ReleaseRefillFacts,
};
use ReleaseRefillDisposition::{
    CmcReconciliation, InvalidReceipt, LedgerReconciliation, NoLedgerTransfer, RecordedConversion,
    RecordedRefund, RefundResidualReview,
};
use canic_core::shared_support::icp_refill::{IcpRefillErrorCode, IcpRefillStatus};

/// Classify the retained receipt, not global release readiness or permission to spend again.
pub(in crate::fleet_ensure) fn assess_refill(
    facts: &ReleaseRefillFacts,
) -> ReleaseRefillDisposition {
    match facts.status {
        IcpRefillStatus::Completed => match (facts.ledger_block_index, facts.cycles) {
            (Some(ledger_block), RecordedRefillCycles::Recorded(cycles))
                if !facts.transfer_uncertain
                    && facts.error_code.is_none()
                    && facts.refund_block_index.is_none()
                    && facts.expired_before_block.is_none() =>
            {
                RecordedConversion {
                    ledger_block,
                    cycles,
                }
            }
            _ => InvalidReceipt,
        },
        IcpRefillStatus::Refunded => {
            if facts.transfer_uncertain
                || facts.error_code != Some(IcpRefillErrorCode::Refunded)
                || facts.cycles != RecordedRefillCycles::Missing
                || facts.expired_before_block.is_some()
            {
                return InvalidReceipt;
            }
            match (facts.ledger_block_index, facts.refund_block_index) {
                (Some(ledger_block), Some(refund_block)) => RecordedRefund {
                    ledger_block,
                    refund_block,
                },
                (Some(ledger_block), None) => RefundResidualReview { ledger_block },
                _ => InvalidReceipt,
            }
        }
        _ => {
            if facts.cycles != RecordedRefillCycles::Missing || facts.refund_block_index.is_some() {
                return InvalidReceipt;
            }
            if let Some(ledger_block) = facts.ledger_block_index {
                return CmcReconciliation { ledger_block };
            }
            if facts.transfer_uncertain {
                return LedgerReconciliation;
            }
            if facts.expired_before_block.is_some() {
                return InvalidReceipt;
            }
            match (facts.status, facts.error_code) {
                (IcpRefillStatus::Requested, None)
                | (
                    IcpRefillStatus::Failed,
                    Some(
                        IcpRefillErrorCode::BadFee
                        | IcpRefillErrorCode::LedgerTransferFailed
                        | IcpRefillErrorCode::TransferWindowStale,
                    ),
                ) => NoLedgerTransfer,
                _ => InvalidReceipt,
            }
        }
    }
}