ic-query 0.96.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

use super::*;
use crate::sns::report::live::types::ListNeuronsRequest;
use crate::sns::report::live::types::SnsGovernanceNeuronPermission;
use ic_platform::candid::contract::Principal;
fn wire() -> SnsGovernanceNeuron {
    SnsGovernanceNeuron {
        id: Some(NeuronId { id: vec![1; 32] }),
        permissions: vec![SnsGovernanceNeuronPermission {
            principal: Some(Principal::management_canister()),
            permission_type: vec![5, 999],
        }],
        cached_neuron_stake_e8s: 125_000_000,
        neuron_fees_e8s: 10,
        maturity_e8s_equivalent: 2,
        staked_maturity_e8s_equivalent: Some(3),
        created_timestamp_seconds: 4,
        source_nns_neuron_id: None,
        auto_stake_maturity: Some(false),
        aging_since_timestamp_seconds: 5,
        dissolve_state: Some(SnsGovernanceDissolveState::DissolveDelaySeconds(60)),
        voting_power_percentage_multiplier: 100,
        vesting_period_seconds: None,
    }
}
#[test]
fn native_stake_projection_keeps_principals_raw_codes_and_distinct_amounts() {
    let neuron = sns_neuron_row(wire()).unwrap();
    assert_eq!(neuron.permissions[0].principal, "aaaaa-aa");
    assert_eq!(neuron.permissions[0].permission_types, [5, 999]);
    assert_eq!(neuron.cached_neuron_stake_e8s, 125_000_000);
    assert_eq!(neuron.neuron_fees_e8s, 10);
    assert_eq!(neuron.staked_maturity_e8s_equivalent, Some(3));
    assert_eq!(
        neuron.dissolve_state,
        Some(SnsNeuronDissolveState::DissolveDelaySeconds(60))
    );
}
#[test]
fn missing_permission_principals_are_not_fabricated() {
    let mut native = wire();
    native.permissions[0].principal = None;
    assert!(matches!(
        sns_neuron_row(native),
        Err(SnsHostError::MissingNeuronPermissionPrincipal {
            permission_index: 0,
            ..
        })
    ));
}
#[test]
fn native_queries_use_the_shared_stake_permission_contract() {
    use crate::sns::report::live::types::{
        GetNeuronResponse, GetNeuronResult, ListNeuronsResponse,
    };
    let bytes = ic_platform::candid::contract::encode_args((ListNeuronsResponse {
        neurons: vec![wire()],
    },))
    .unwrap();
    let response: ListNeuronsResponse = crate::candid_decode::decode_reply(&bytes).unwrap();
    assert_eq!(
        sns_neuron_row(response.neurons.into_iter().next().unwrap())
            .unwrap()
            .permissions[0]
            .permission_types,
        [5, 999]
    );
    let bytes = ic_platform::candid::contract::encode_args((GetNeuronResponse {
        result: Some(GetNeuronResult::Neuron(Box::new(wire()))),
    },))
    .unwrap();
    let response: GetNeuronResponse = crate::candid_decode::decode_reply(&bytes).unwrap();
    let Some(GetNeuronResult::Neuron(neuron)) = response.result else {
        panic!("expected neuron")
    };
    assert_eq!(
        sns_neuron_row(*neuron).unwrap().cached_neuron_stake_e8s,
        125_000_000
    );
}

#[test]
fn neuron_cursor_keeps_the_external_request_shape_and_raw_bytes() {
    let cursor = crate::sns::report::SnsNeuronId { id: vec![0xff; 32] };
    let request = ListNeuronsRequest {
        of_principal: None,
        limit: 1,
        start_page_at: Some((&cursor).into()),
    };
    // Independent didc encoding, including the optional record/blob cursor.
    let expected = crate::hex::decode_hex("4449444c056c03c69cb8c20401bbbe84a8077986d8d2800f026e686e036c01dbb701046d7b010000010000000120ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
    assert_eq!(
        ic_platform::candid::contract::encode_one(request).unwrap(),
        expected
    );
    let wire = NeuronId::from(&cursor);
    let bytes = ic_platform::candid::contract::encode_one(wire).unwrap();
    let decoded: NeuronId = crate::candid_decode::decode_reply(&bytes).unwrap();
    assert_eq!(crate::sns::report::SnsNeuronId::from(decoded), cursor);
}