ic-query 0.100.0

Internet Computer query library for CloudEngine, 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::ic_registry::RegistryFetchError;
use crate::subnet_catalog::SubnetCatalogRegistryValueEncoding;
use ic_host_tools::registry::proto::LargeValueChunkKeys;
#[cfg(feature = "nns-host")]
use ic_platform::Principal;
use serde::Deserialize;

///
/// RegistryValueContent
///
/// Decoded content returned by a registry value lookup.
///

#[derive(Debug)]
pub(super) enum RegistryValueContent {
    Value(Vec<u8>),
    LargeValueChunkKeys(LargeValueChunkKeys),
}

///
/// RegistryVersionedValue
///
/// Completed value plus the individual mutation provenance returned by Registry.
///

#[derive(Debug, Eq, PartialEq)]
pub(super) struct RegistryVersionedValue {
    pub(super) value: Vec<u8>,
    pub(super) version: u64,
    pub(super) timestamp_nanoseconds: u64,
    pub(super) encoding: SubnetCatalogRegistryValueEncoding,
}

///
/// RegistryVersionedValueFailure
///
/// Value-fetch failure retaining response provenance when Registry supplied it.
///

#[derive(Debug)]
pub(super) struct RegistryVersionedValueFailure {
    pub(super) source: RegistryFetchError,
    pub(super) returned_version: Option<u64>,
}

///
/// RegistryGetChunkRequest
///
/// Candid request for one chunk of a large registry value.
///

#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]

pub(super) struct RegistryGetChunkRequest {
    pub(super) content_sha256: Option<Vec<u8>>,
}

ic_platform::candid_record!(RegistryGetChunkRequest {
    603_009_517 => content_sha256: Option<Vec<u8>>
});

///
/// RegistryChunk
///
/// Candid response containing one validated registry value chunk.
///

#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]

pub(super) struct RegistryChunk {
    pub(super) content: Option<Vec<u8>>,
}

ic_platform::candid_record!(RegistryChunk {
    427_265_337 => content: Option<Vec<u8>>
});

///
/// ListNodeProvidersResponse
///
/// Candid governance response containing the current node providers.
///

#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
#[cfg(feature = "nns-host")]
pub(super) struct ListNodeProvidersResponse {
    pub(super) node_providers: Vec<GovernanceNodeProvider>,
}

#[cfg(feature = "nns-host")]
ic_platform::candid_record!(ListNodeProvidersResponse {
    1_989_342_821 => node_providers: Vec<GovernanceNodeProvider>
});

///
/// GovernanceNodeProvider
///
/// Candid node provider record returned by NNS governance.
///

#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
#[cfg(feature = "nns-host")]
pub(super) struct GovernanceNodeProvider {
    pub(super) id: Option<Principal>,
    pub(super) reward_account: Option<GovernanceAccountIdentifier>,
}

#[cfg(feature = "nns-host")]
ic_platform::candid_record!(GovernanceNodeProvider {
    23_515 => id: Option<Principal>,
    2_095_839_389 => reward_account: Option<GovernanceAccountIdentifier>
});

///
/// GovernanceAccountIdentifier
///
/// Candid account identifier attached to a governance node provider.
///

#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
#[cfg(feature = "nns-host")]
pub(super) struct GovernanceAccountIdentifier {
    pub(super) hash: Vec<u8>,
}

#[cfg(feature = "nns-host")]
ic_platform::candid_record!(GovernanceAccountIdentifier {
    1_158_164_430 => hash: Vec<u8>
});