ic-query 0.102.0

Internet Computer query library for CloudEngine, NNS, SNS, ICRC, system canisters, and public network metadata
Documentation
use super::*;
use crate::sns::report::SnsNeuronDissolveState;
use crate::sns::report::live::types::ListNeuronsRequest;
use crate::sns::report::live::types::SnsGovernanceNeuronPermission;
use ic_platform::Principal;
fn wire() -> SnsGovernanceNeuron {
    SnsGovernanceNeuron {
        id: Some(SnsNeuronId { 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(SnsNeuronDissolveState::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 = crate::candid_codec::encode_arguments(&(ListNeuronsResponse {
        neurons: vec![wire()],
    },))
    .unwrap();
    let response: ListNeuronsResponse = crate::candid_codec::decode_reply(&bytes).unwrap();
    assert_eq!(
        sns_neuron_row(response.neurons.into_iter().next().unwrap())
            .unwrap()
            .permissions[0]
            .permission_types,
        [5, 999]
    );
    let bytes = crate::candid_codec::encode_arguments(&(GetNeuronResponse {
        result: Some(GetNeuronResult::Neuron(wire())),
    },))
    .unwrap();
    let response: GetNeuronResponse = crate::candid_codec::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.clone()),
    };
    // Independent didc encoding, including the optional record/blob cursor.
    let expected = crate::hex::decode_hex("4449444c056c03c69cb8c20401bbbe84a8077986d8d2800f026e686e036c01dbb701046d7b010000010000000120ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
    assert_eq!(
        crate::candid_codec::encode_value(&request).unwrap(),
        expected
    );
    let wire = cursor.clone();
    let bytes = crate::candid_codec::encode_value(&wire).unwrap();
    let decoded: SnsNeuronId = crate::candid_codec::decode_reply(&bytes).unwrap();
    assert_eq!(decoded, cursor);
}

#[test]
fn dissolve_state_codec_preserves_external_variants_and_json_tags() {
    for (hex, state, kind, value) in [
        (
            "4449444c016b02ede4dd84067882d884e50f780100003c00000000000000",
            SnsNeuronDissolveState::DissolveDelaySeconds(60),
            "dissolve_delay_seconds",
            60,
        ),
        (
            "4449444c016b02ede4dd84067882d884e50f780100017800000000000000",
            SnsNeuronDissolveState::WhenDissolvedTimestampSeconds(120),
            "when_dissolved_timestamp_seconds",
            120,
        ),
    ] {
        // Literal external Candid variant labels with nat64 payloads.
        let bytes = crate::hex::decode_hex(hex).unwrap();
        let decoded: SnsNeuronDissolveState = crate::candid_codec::decode_reply(&bytes).unwrap();
        assert_eq!(decoded, state);
        assert_eq!(
            serde_json::to_value(state).unwrap(),
            serde_json::json!({"kind":kind,"value":value})
        );
        assert_eq!(crate::candid_codec::encode_value(&state).unwrap(), bytes);
        assert!(
            crate::candid_codec::decode_reply::<SnsNeuronDissolveState>(&bytes[..bytes.len() - 1])
                .is_err()
        );
    }
}