ic-query 0.79.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
130
131

use super::{fixtures::*, *};
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 text = sns_token_report_text(&report);
    let json = serde_json::to_value(&report).expect("serialize raw report");
    let escaped = "界 e\u{301}\\u{202e}\\u{2028}\\u{2029}\\u{2069}\\u{9b}\\u{1b}[31m";
    assert!(text.contains(&format!("token_symbol: {escaped}")));
    assert!(
        text.lines()
            .any(|line| line.starts_with("icrc1:name") && line.ends_with(escaped))
    );
    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 text = sns_token_report_text(&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.id, 1);
    assert_eq!(report.name, "Fixture SNS");
    assert_eq!(report.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_canister_id.as_deref(), Some(INDEX_A));
    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"));
    assert!(text.contains("token_symbol: FIX"));
    assert!(text.contains("transfer_fee: 0.00"));
    assert!(text.contains("total_supply: 10.00"));
    assert!(!text.contains("10_000"));
    assert!(!text.contains("1_000_000_000"));
    assert!(text.contains("ledger_index_canister_id: bw4dl-smaaa-aaaaa-qaacq-cai"));
    assert!(text.contains("ICRC-1"));
    assert!(text.contains("icrc1:name"));
    assert!(text.contains("icrc1:fee"));
    assert!(text.contains("icrc1:logo"));
    assert!(text.contains("present"));
    assert!(!text.contains("data:image"));
}

#[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_canister_id, None);
    assert_eq!(report.ledger_index_error.as_deref(), Some(error));
    let json = serde_json::to_value(&report).unwrap();
    assert_eq!(json["ledger_index_canister_id"], serde_json::Value::Null);
    assert_eq!(json["ledger_index_error"], error);
}