ic-query 0.25.1

Internet Computer query library for NNS, SNS, ICRC, system canisters, and public network metadata
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

//! Module: sns::report::live::fetch::swap
//!
//! Responsibility: fetch bounded SNS swap lifecycle and sale state.
//! Does not own: SNS lookup, source validation, report assembly, cache IO, or rendering.
//! Boundary: attempts exactly three small public queries and retains component failures as gaps.

use super::block_on_sns;
use crate::sns::report::{
    MainnetSns, MainnetSnsSwap, SnsHostError, SnsSourceRequest, SnsSwapComponent, SnsSwapQueryGap,
    live::{
        convert::{sns_swap_derived_state, sns_swap_lifecycle, sns_swap_sale_parameters},
        query::{principal_from_text, query_canister, sns_agent},
        types::{
            GetDerivedStateResponse, GetLifecycleResponse, GetSaleParametersResponse,
            SnsSwapQueryRequest,
        },
    },
    source::{
        SNS_SWAP_DERIVED_STATE_METHOD, SNS_SWAP_LIFECYCLE_METHOD, SNS_SWAP_SALE_PARAMETERS_METHOD,
        sns_swap_component_method,
    },
};

/// Fetch the three bounded native state components for one resolved SNS swap.
pub(in crate::sns::report::live) fn fetch_mainnet_sns_swap(
    request: &SnsSourceRequest,
    sns: &MainnetSns,
) -> Result<MainnetSnsSwap, SnsHostError> {
    block_on_sns(fetch_mainnet_sns_swap_async(request, sns))
}

async fn fetch_mainnet_sns_swap_async(
    request: &SnsSourceRequest,
    sns: &MainnetSns,
) -> Result<MainnetSnsSwap, SnsHostError> {
    let agent = sns_agent(request)?;
    let swap_canister = principal_from_text(&sns.swap_canister_id, "swap_canister_id")?;
    let request = SnsSwapQueryRequest {};
    let mut gaps = Vec::new();

    let lifecycle = match query_canister::<_, GetLifecycleResponse>(
        &agent,
        &swap_canister,
        SNS_SWAP_LIFECYCLE_METHOD,
        "SnsSwapQueryRequest",
        "GetLifecycleResponse",
        &request,
    )
    .await
    {
        Ok(response) => Some(sns_swap_lifecycle(response)),
        Err(error) => {
            gaps.push(query_gap(SnsSwapComponent::Lifecycle, error));
            None
        }
    };
    let sale_parameters = match query_canister::<_, GetSaleParametersResponse>(
        &agent,
        &swap_canister,
        SNS_SWAP_SALE_PARAMETERS_METHOD,
        "SnsSwapQueryRequest",
        "GetSaleParametersResponse",
        &request,
    )
    .await
    {
        Ok(response) => sns_swap_sale_parameters(response),
        Err(error) => {
            gaps.push(query_gap(SnsSwapComponent::SaleParameters, error));
            None
        }
    };
    let derived_state = match query_canister::<_, GetDerivedStateResponse>(
        &agent,
        &swap_canister,
        SNS_SWAP_DERIVED_STATE_METHOD,
        "SnsSwapQueryRequest",
        "GetDerivedStateResponse",
        &request,
    )
    .await
    {
        Ok(response) => Some(sns_swap_derived_state(response)),
        Err(error) => {
            gaps.push(query_gap(SnsSwapComponent::DerivedState, error));
            None
        }
    };

    Ok(MainnetSnsSwap {
        swap_canister_id: sns.swap_canister_id.clone(),
        lifecycle_method: SNS_SWAP_LIFECYCLE_METHOD.to_string(),
        sale_parameters_method: SNS_SWAP_SALE_PARAMETERS_METHOD.to_string(),
        derived_state_method: SNS_SWAP_DERIVED_STATE_METHOD.to_string(),
        point_in_time_guaranteed: false,
        lifecycle,
        sale_parameters,
        derived_state,
        gaps,
    })
}

fn query_gap(component: SnsSwapComponent, error: SnsHostError) -> SnsSwapQueryGap {
    SnsSwapQueryGap {
        component,
        method: sns_swap_component_method(component).to_string(),
        reason: error.to_string(),
    }
}