idl2json 0.10.1

Converts the candid interface description language to JSON.
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

use crate::{BytesFormat, Idl2JsonOptions};
use candid::types::value::IDLValue;
use serde_json::value::Value as JsonValue;
use sha2::{Digest, Sha256};

/// Converts supposedly binary data.  Returns an error if the data is not binary.
pub fn convert_bytes(bytes: &[IDLValue], options: &Idl2JsonOptions) -> Result<JsonValue, ()> {
    if let Some((len, bytes_format)) = options.long_bytes_as {
        if bytes.len() >= len {
            return format_bytes(bytes, &bytes_format);
        }
    }
    format_bytes(bytes, &(options.bytes_as.unwrap_or_default()))
}
/// Formats supposedly binary data.  Returns an error if the data is not binary.
fn format_bytes(bytes: &[IDLValue], bytes_format: &BytesFormat) -> Result<JsonValue, ()> {
    match bytes_format {
        BytesFormat::Numbers => Ok(JsonValue::Array(
            bytes
                .iter()
                .map(|item| {
                    if let IDLValue::Nat8(value) = item {
                        Ok(JsonValue::Number(serde_json::Number::from(*value)))
                    } else {
                        Err(())
                    }
                })
                .collect::<Result<Vec<JsonValue>, ()>>()?,
        )),
        BytesFormat::Hex => {
            let mut ans = String::with_capacity(bytes.len() * 2);
            for byte in bytes {
                if let IDLValue::Nat8(value) = byte {
                    ans.push_str(nybble2hex(value >> 4));
                    ans.push_str(nybble2hex(value & 0xf));
                } else {
                    return Err(());
                }
            }
            Ok(JsonValue::String(ans))
        }
        #[cfg(feature = "crypto")]
        BytesFormat::Sha256 => {
            let mut hasher = Sha256::new();
            for byte in bytes {
                if let IDLValue::Nat8(value) = byte {
                    hasher.update([*value]);
                } else {
                    return Err(());
                }
            }
            let digest = hasher.finalize();
            Ok(JsonValue::String(format!("Bytes with sha256: {digest:x}")))
        }
    }
}

// Converts binary data according to the args.
/// Converts supposedly binary data.  Returns an error if the data is not binary.
pub fn convert_blob(bytes: &[u8], options: &Idl2JsonOptions) -> JsonValue {
    if let Some((len, bytes_format)) = options.long_bytes_as {
        if bytes.len() >= len {
            return format_blob(bytes, &bytes_format);
        }
    }
    format_blob(bytes, &(options.bytes_as.unwrap_or_default()))
}

/// Formats binary data.  Returns an error if the data is not binary.
pub fn format_blob(bytes: &[u8], bytes_format: &BytesFormat) -> JsonValue {
    match bytes_format {
        BytesFormat::Numbers => JsonValue::Array(
            bytes
                .iter()
                .map(|value| JsonValue::Number(serde_json::Number::from(*value)))
                .collect::<Vec<JsonValue>>(),
        ),
        BytesFormat::Hex => {
            let mut ans = String::with_capacity(bytes.len() * 2);
            for value in bytes {
                ans.push_str(nybble2hex(value >> 4));
                ans.push_str(nybble2hex(value & 0xf));
            }
            JsonValue::String(ans)
        }
        #[cfg(feature = "crypto")]
        BytesFormat::Sha256 => {
            let mut hasher = Sha256::new();
            for value in bytes {
                hasher.update([*value]);
            }
            let digest = hasher.finalize();
            JsonValue::String(format!("Bytes with sha256: {digest:x}"))
        }
    }
}

fn nybble2hex(nybble: u8) -> &'static str {
    match nybble {
        0 => "0",
        1 => "1",
        2 => "2",
        3 => "3",
        4 => "4",
        5 => "5",
        6 => "6",
        7 => "7",
        8 => "8",
        9 => "9",
        10 => "a",
        11 => "b",
        12 => "c",
        13 => "d",
        14 => "e",
        15 => "f",
        _ => "?",
    }
}