canic-core 0.110.10

Canic — a canister orchestration and management toolkit for the Internet Computer
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

//! Module: ops::ic::cycles_ledger
//!
//! Responsibility: expose approved Cycles Ledger pool-refill calls.
//! Does not own: refill policy, stable creation journals, or inventory mutation.
//! Boundary: effect calls require a workflow-owned cost-guard permit.

use crate::{
    InternalError,
    cdk::types::{Cycles, Principal},
    dto::fleet_registry::FleetLedgerTransferIntent,
    infra::ic::{
        IcInfraError,
        cycles_ledger::{
            CyclesLedgerCreateCanisterError, CyclesLedgerCreateCanisterSuccess, CyclesLedgerInfra,
            CyclesLedgerTransferError,
        },
    },
    ops::{OpsError, cost_guard::CostGuardPermit},
};
use candid::Nat;

/// Operations facade for the IC-mainnet Cycles Ledger.
pub struct CyclesLedgerOps;

impl CyclesLedgerOps {
    #[must_use]
    pub fn canister_id() -> Principal {
        CyclesLedgerInfra::canister_id()
    }

    pub async fn create_canister(
        _permit: &CostGuardPermit,
        root: Principal,
        subnet: Principal,
        amount: Cycles,
        created_at_time: u64,
    ) -> Result<
        Result<CyclesLedgerCreateCanisterSuccess, CyclesLedgerCreateCanisterError>,
        InternalError,
    > {
        map_infra(CyclesLedgerInfra::create_canister(root, subnet, amount, created_at_time).await)
    }

    pub async fn transfer(
        _permit: &CostGuardPermit,
        intent: &FleetLedgerTransferIntent,
    ) -> Result<Result<Nat, CyclesLedgerTransferError>, InternalError> {
        if intent.source != crate::ops::ic::IcOps::canister_self() {
            return Err(InternalError::conflict());
        }
        map_infra(CyclesLedgerInfra::transfer(intent).await)
    }

    pub async fn balance_of(root: Principal) -> Result<Cycles, InternalError> {
        let balance = map_infra(CyclesLedgerInfra::balance_of(root).await)?;
        Self::checked_cycles(balance)
    }

    pub async fn fee() -> Result<Cycles, InternalError> {
        let fee = map_infra(CyclesLedgerInfra::fee().await)?;
        Self::checked_cycles(fee)
    }

    pub fn checked_block_index(value: Nat) -> Result<u64, InternalError> {
        map_infra(CyclesLedgerInfra::checked_block_index(value))
    }

    pub fn checked_cycles(value: Nat) -> Result<Cycles, InternalError> {
        map_infra(CyclesLedgerInfra::checked_cycles(value))
    }
}

fn map_infra<T>(result: Result<T, IcInfraError>) -> Result<T, InternalError> {
    result.map_err(OpsError::from).map_err(InternalError::from)
}