ic-platform 0.6.14

Controlled Candid and IC runtime dependency boundary
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

use super::StrictReserved;
use crate::candid::{DecodeLimits, decode_exactly_one};
use candid::CandidType;
use serde::Deserialize;

#[test]
fn reserved_encoding_and_zero_skip_admission_match_candid() {
    let wire = candid::encode_one(StrictReserved).unwrap();
    assert_eq!(wire, candid::encode_one(candid::Reserved).unwrap());
    let limits = DecodeLimits {
        reply_bytes: 1024,
        decoding_quota: 10_000,
        skipping_quota: 0,
        type_entries: 4,
        header_bytes: 128,
    };
    assert!(decode_exactly_one::<StrictReserved>(&wire, limits).is_ok());
    for wire in [
        candid::encode_one(7_u64).unwrap(),
        candid::encode_one(vec![3_u8]).unwrap(),
    ] {
        assert!(decode_exactly_one::<StrictReserved>(&wire, limits).is_err());
        assert!(
            decode_exactly_one::<StrictReserved>(
                &wire,
                DecodeLimits {
                    skipping_quota: 10_000,
                    ..limits
                }
            )
            .is_ok()
        );
    }
}

#[test]
fn recognized_variant_tags_do_not_hide_arbitrary_payloads() {
    #[derive(CandidType, Deserialize)]
    enum Strict {
        #[serde(rename = "source")]
        Source(StrictReserved),
    }
    #[derive(CandidType, Deserialize)]
    enum Untrusted {
        #[serde(rename = "source")]
        Source(u64),
    }
    let limits = DecodeLimits {
        reply_bytes: 1024,
        decoding_quota: 10_000,
        skipping_quota: 0,
        type_entries: 4,
        header_bytes: 128,
    };
    let valid = candid::encode_one(Strict::Source(StrictReserved)).unwrap();
    assert!(decode_exactly_one::<Strict>(&valid, limits).is_ok());
    let invalid = candid::encode_one(Untrusted::Source(7)).unwrap();
    assert!(decode_exactly_one::<Strict>(&invalid, limits).is_err());
}