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

use super::*;

#[derive(Debug, PartialEq, serde::Deserialize)]

enum Tree {
    Leaf(u64),
    Branch(Vec<Self>),
}

ic_platform::candid_variant!(Tree {
    847_851_454 => Leaf(u64),
    1_202_549_442 => Branch(Vec<Tree>)
});

#[test]
fn external_nat64_wire_vector_is_unchanged() {
    let bytes = b"DIDL\x00\x01\x78\x2a\x00\x00\x00\x00\x00\x00\x00";
    assert_eq!(crate::candid_codec::encode_value(&42_u64).unwrap(), bytes);
    assert_eq!(decode_reply::<u64>(bytes).unwrap(), 42);
}

#[test]
fn accepts_wide_recursive_typed_values() {
    let value = Tree::Branch(
        (0..10_000)
            .map(|index| {
                Tree::Branch(vec![
                    Tree::Leaf(index),
                    Tree::Branch(vec![Tree::Leaf(index + 1)]),
                ])
            })
            .collect(),
    );
    let bytes = crate::candid_codec::encode_value(&value).unwrap();
    assert_eq!(decode_reply::<Tree>(&bytes).unwrap(), value);
}

#[test]
fn rejects_amplified_skipping_in_a_small_reply() {
    let ordinary = crate::candid_codec::encode_arguments(&(42u64, "unused")).unwrap();
    assert_eq!(decode_reply::<u64>(&ordinary).unwrap(), 42);
    let bytes = crate::candid_codec::encode_arguments(&(42u64, vec![(); 100_000])).unwrap();
    assert!(bytes.len() < 32);
    assert!(decode_reply::<u64>(&bytes).is_err());
}

#[test]
fn skipped_external_values_retain_platform_nesting_admission_and_typed_errors() {
    let shallow = Tree::Branch(vec![Tree::Leaf(1)]);
    let deep = (0..16).fold(Tree::Leaf(1), |child, _| Tree::Branch(vec![child]));
    let ordinary = crate::candid_codec::encode_arguments(&(42_u64, shallow)).unwrap();
    assert_eq!(decode_reply::<u64>(&ordinary).unwrap(), 42);

    let nested = crate::candid_codec::encode_arguments(&(42_u64, deep)).unwrap();
    assert!(matches!(
        decode_reply::<u64>(&nested),
        Err(CandidReplyError::Budget)
    ));
}

#[test]
fn rejects_amplified_decoding_in_a_small_reply() {
    let bytes = crate::candid_codec::encode_value(&vec![(); 1_000_000]).unwrap();
    assert!(bytes.len() < 32);
    assert!(decode_reply::<Vec<()>>(&bytes).is_err());
}

#[test]
fn accepts_a_large_byte_vector() {
    let value = vec![7u8; 8 * 1024 * 1024 - 32];
    let bytes = crate::candid_codec::encode_value(&value).unwrap();
    assert_eq!(decode_reply::<Vec<u8>>(&bytes).unwrap(), value);
}

#[test]
fn rejects_an_excessive_type_table_before_reading_entries() {
    // DIDL followed by the unsigned LEB128 type count 4097.
    let bytes = b"DIDL\x81\x20";
    assert!(matches!(
        decode_reply::<u64>(bytes),
        Err(CandidReplyError::Budget)
    ));
}