ic-platform 0.30.0

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

//! Small external Candid argument encoders without the general Candid library.
//!
//! Only empty tuples, lists of unit/null arguments and a single text argument are
//! supported. Callers retain method selection, budgets and transport. Owned
//! application protocols continue to use Wire.

/// Exact zero-argument envelope, without allocation or failure.
pub const fn empty() -> &'static [u8; 6] {
    b"DIDL\0\0"
}

/// Encode `count` unit/null arguments: zero gives `()`, two gives `((), ())`.
///
/// The count is caller-selected; no resource limit is inferred.
pub fn units(count: usize) -> Vec<u8> {
    let mut bytes = header(count, count);
    bytes.extend(core::iter::repeat_n(0x7f, count));
    bytes
}

/// Encode one text argument with its exact UTF-8 bytes and byte length.
pub fn text(value: &str) -> Vec<u8> {
    let mut bytes = header(1, 1 + unsigned_len(value.len()) + value.len());
    bytes.push(0x71);
    unsigned(value.len(), &mut bytes);
    bytes.extend_from_slice(value.as_bytes());
    bytes
}

fn header(count: usize, payload_bytes: usize) -> Vec<u8> {
    // Saturation leaves impossible sizes to Vec's ordinary capacity refusal.
    let capacity = (5 + unsigned_len(count)).saturating_add(payload_bytes);
    let mut bytes = Vec::with_capacity(capacity);
    bytes.extend_from_slice(b"DIDL\0");
    unsigned(count, &mut bytes);
    bytes
}

fn unsigned_len(value: usize) -> usize {
    ((usize::BITS - value.leading_zeros()).max(1) as usize).div_ceil(7)
}

fn unsigned(mut value: usize, bytes: &mut Vec<u8>) {
    loop {
        let byte = (value & 0x7f) as u8;
        value >>= 7;
        bytes.push(byte | if value == 0 { 0 } else { 0x80 });
        if value == 0 {
            return;
        }
    }
}