canic-core 0.31.0

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
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

use crate::{
    InternalError,
    cdk::{
        env::nns::EXCHANGE_RATE_CANISTER,
        spec::standards::xrc::{ExchangeRate, GetExchangeRateRequest, GetExchangeRateResult},
    },
    ops::{
        ic::{IcOpsError, call::CallOps},
        runtime::metrics::platform_call::{
            PlatformCallMetricMode, PlatformCallMetricOutcome, PlatformCallMetricReason,
            PlatformCallMetricSurface, PlatformCallMetrics,
        },
    },
};
use thiserror::Error as ThisError;

///
/// XrcOpsError
///

#[derive(Debug, ThisError)]
pub enum XrcOpsError {
    #[error("xrc rejected exchange rate request: {reason}")]
    Rejected { reason: String },
}

impl From<XrcOpsError> for InternalError {
    fn from(err: XrcOpsError) -> Self {
        IcOpsError::from(err).into()
    }
}

///
/// XrcOps
///

pub struct XrcOps;

impl XrcOps {
    /// Default cycles to attach to XRC calls.
    pub const DEFAULT_XRC_CYCLES: u128 = 0;

    pub async fn get_exchange_rate(
        req: GetExchangeRateRequest,
        cycles: u128,
    ) -> Result<ExchangeRate, InternalError> {
        record_xrc_call(
            PlatformCallMetricOutcome::Started,
            PlatformCallMetricReason::Ok,
        );
        let builder = match CallOps::unbounded_wait(*EXCHANGE_RATE_CANISTER, "get_exchange_rate")
            .with_cycles(cycles)
            .with_arg(req)
        {
            Ok(builder) => builder,
            Err(err) => {
                record_xrc_call(
                    PlatformCallMetricOutcome::Failed,
                    PlatformCallMetricReason::CandidEncode,
                );
                return Err(err);
            }
        };
        let response = match builder.execute().await {
            Ok(response) => response,
            Err(err) => {
                record_xrc_call(
                    PlatformCallMetricOutcome::Failed,
                    PlatformCallMetricReason::Infra,
                );
                return Err(err);
            }
        };

        let res: GetExchangeRateResult = match response.candid() {
            Ok(res) => res,
            Err(err) => {
                record_xrc_call(
                    PlatformCallMetricOutcome::Failed,
                    PlatformCallMetricReason::CandidDecode,
                );
                return Err(err);
            }
        };

        match res {
            GetExchangeRateResult::Ok(rate) => {
                record_xrc_call(
                    PlatformCallMetricOutcome::Completed,
                    PlatformCallMetricReason::Ok,
                );
                Ok(rate)
            }
            GetExchangeRateResult::Err(err) => {
                record_xrc_call(
                    PlatformCallMetricOutcome::Failed,
                    PlatformCallMetricReason::Rejected,
                );
                Err(XrcOpsError::Rejected {
                    reason: format!("{err:?}"),
                }
                .into())
            }
        }
    }
}

// Record one XRC metric with no asset, quote, or provider dimensions.
fn record_xrc_call(outcome: PlatformCallMetricOutcome, reason: PlatformCallMetricReason) {
    PlatformCallMetrics::record(
        PlatformCallMetricSurface::Xrc,
        PlatformCallMetricMode::UnboundedWait,
        outcome,
        reason,
    );
}