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

use super::fixtures::*;
use super::*;
use crate::icrc::IcrcIndexData;
use ic_platform::icrc_ledger_types::MetadataValue;

#[tokio::test(flavor = "current_thread")]
async fn sns_token_text_escapes_unsafe_unicode_without_changing_json_evidence() {
    let mut report = build_sns_token_report_with_source(
        &token_request("1"),
        &FixtureSnsTokenSource(IcrcIndexData::Found(INDEX_A.to_string())),
    )
    .await
    .expect("sns token report");
    let raw = "界 e\u{301}\u{202e}\u{2028}\u{2029}\u{2069}\u{009b}\u{1b}[31m";
    report.token.token_symbol = raw.to_string();
    report.token.metadata[0].value = serde_json::json!(raw);

    let json = serde_json::to_value(&report).expect("serialize raw report");

    assert_eq!(json["token_symbol"], serde_json::json!(raw));
    assert_eq!(json["metadata"][0]["value"], serde_json::json!(raw));
    assert_eq!(report.token.token_symbol, raw);
}

#[tokio::test(flavor = "current_thread")]
async fn sns_token_resolves_list_id_and_renders_ledger_metadata() {
    let request = token_request("1");

    let report = build_sns_token_report_with_source(
        &request,
        &FixtureSnsTokenSource(IcrcIndexData::Found(INDEX_A.to_string())),
    )
    .await
    .expect("sns token report");

    let json = serde_json::to_value(&report).expect("serialize SNS token report");

    assert_eq!(report.schema_version, SNS_TOKEN_REPORT_SCHEMA_VERSION);
    assert_eq!(report.context.id, 1);
    assert_eq!(report.context.name, "Fixture SNS");
    assert_eq!(report.context.root_canister_id, ROOT_A);
    assert_eq!(report.ledger_canister_id, LEDGER_A);
    assert_eq!(report.sns_index_canister_id, INDEX_A);
    assert_eq!(
        report.ledger_index,
        IcrcIndexData::Found(INDEX_A.to_string())
    );
    assert_eq!(report.token.token_name, "Fixture Token");
    assert_eq!(report.token.token_symbol, "FIX");
    assert_eq!(report.token.decimals, 8);
    assert_eq!(report.token.transfer_fee, "10_000");
    assert_eq!(report.token.total_supply, "1_000_000_000");
    assert_eq!(
        report.token.minting_account_owner.as_deref(),
        Some(GOVERNANCE_A)
    );
    assert_eq!(
        report.token.minting_account_subaccount_hex.as_deref(),
        Some("000102")
    );
    assert_eq!(report.token.supported_standards[0].name, "ICRC-1");
    assert_eq!(report.token.metadata[0].key, "icrc1:name");
    assert!(
        report
            .token
            .metadata
            .iter()
            .any(|row| row.key == "icrc1:logo"
                && row.value_type == IcrcMetadataValueKind::Text
                && row.value == serde_json::json!("data:image/png;base64,fixture"))
    );
    assert_eq!(json["metadata"][0]["value_type"], serde_json::json!("text"));
}

#[test]
fn sns_token_logo_metadata_preserves_raw_text() {
    let row = metadata_row(
        "icrc1:logo".to_string(),
        MetadataValue::Text("data:image/png;base64,large-logo".to_string()),
    );

    assert_eq!(row.key, "icrc1:logo");
    assert_eq!(row.value_type, IcrcMetadataValueKind::Text);
    assert_eq!(
        row.value,
        serde_json::json!("data:image/png;base64,large-logo")
    );
}

#[test]
fn sns_token_empty_logo_metadata_remains_raw() {
    let row = metadata_row(
        "icrc1:logo".to_string(),
        MetadataValue::Text(" ".to_string()),
    );

    assert_eq!(row.value_type, IcrcMetadataValueKind::Text);
    assert_eq!(row.value, serde_json::json!(" "));
}

#[tokio::test(flavor = "current_thread")]
async fn sns_token_retains_metadata_when_ledger_index_discovery_is_unavailable() {
    let error = "ledger index discovery request timed out";
    let report = build_sns_token_report_with_source(
        &token_request("1"),
        &FixtureSnsTokenSource(IcrcIndexData::Unavailable(error.to_string())),
    )
    .await
    .expect("metadata survives index discovery failure");
    assert_eq!(report.token.token_symbol, "FIX");
    assert_eq!(report.sns_index_canister_id, INDEX_A);
    assert_eq!(
        report.ledger_index,
        IcrcIndexData::Unavailable(error.to_string())
    );
    let json = serde_json::to_value(&report).unwrap();
    assert_eq!(
        json["ledger_index"],
        serde_json::json!({"unavailable": error})
    );
}