dig-capsule 0.5.0

The DIG Network .dig capsule data plane — one crate over the DIGS format, capsule read-crypto, compiler, staging, and the guest/host serve triad.
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

//! Big-endian Chia framing for primitive types.

use super::{utf8_from, Decode, DecodeError, Decoder, Encode, Encoder};
use alloc::string::String;
use alloc::vec::Vec;

macro_rules! impl_uint {
    ($t:ty, $n:expr) => {
        impl Encode for $t {
            fn encode(&self, enc: &mut Encoder) {
                enc.write_bytes(&self.to_be_bytes());
            }
        }
        impl Decode for $t {
            fn decode(dec: &mut Decoder<'_>) -> Result<Self, DecodeError> {
                let bytes = dec.read_bytes($n)?;
                let mut arr = [0u8; $n];
                arr.copy_from_slice(bytes);
                Ok(<$t>::from_be_bytes(arr))
            }
        }
    };
}

impl_uint!(u8, 1);
impl_uint!(u16, 2);
impl_uint!(u32, 4);
impl_uint!(u64, 8);

impl<T: Encode> Encode for Option<T> {
    fn encode(&self, enc: &mut Encoder) {
        match self {
            None => enc.write_bytes(&[0u8]),
            Some(v) => {
                enc.write_bytes(&[1u8]);
                v.encode(enc);
            }
        }
    }
}

impl<T: Decode> Decode for Option<T> {
    fn decode(dec: &mut Decoder<'_>) -> Result<Self, DecodeError> {
        let tag = dec.read_bytes(1)?[0];
        match tag {
            0 => Ok(None),
            1 => Ok(Some(T::decode(dec)?)),
            other => Err(DecodeError::InvalidTag(other)),
        }
    }
}

impl<T: Encode> Encode for Vec<T> {
    fn encode(&self, enc: &mut Encoder) {
        (self.len() as u32).encode(enc);
        for item in self {
            item.encode(enc);
        }
    }
}

impl<T: Decode> Decode for Vec<T> {
    fn decode(dec: &mut Decoder<'_>) -> Result<Self, DecodeError> {
        let count = u32::decode(dec)? as usize;
        let mut out = Vec::with_capacity(count.min(1024));
        for _ in 0..count {
            out.push(T::decode(dec)?);
        }
        Ok(out)
    }
}

impl Encode for String {
    fn encode(&self, enc: &mut Encoder) {
        let bytes = self.as_bytes();
        (bytes.len() as u32).encode(enc);
        enc.write_bytes(bytes);
    }
}

impl Decode for String {
    fn decode(dec: &mut Decoder<'_>) -> Result<Self, DecodeError> {
        let len = u32::decode(dec)? as usize;
        let bytes = dec.read_bytes(len)?;
        utf8_from(bytes)
    }
}

macro_rules! impl_fixed_array {
    ($n:expr) => {
        impl Encode for [u8; $n] {
            fn encode(&self, enc: &mut Encoder) {
                enc.write_bytes(self);
            }
        }
        impl Decode for [u8; $n] {
            fn decode(dec: &mut Decoder<'_>) -> Result<Self, DecodeError> {
                let bytes = dec.read_bytes($n)?;
                let mut arr = [0u8; $n];
                arr.copy_from_slice(bytes);
                Ok(arr)
            }
        }
    };
}

impl_fixed_array!(4); // used by tests + small fixed fields
impl_fixed_array!(32);
impl_fixed_array!(48);
impl_fixed_array!(96);