agglayer-bincode 0.8.0

Agglayer Bincode utilities
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
119
120
121
122

pub use bincode::{Error, ErrorKind, Options, Result};

/// Bincode configuration. Deliberately inaccessible from the outside.
mod options {
    use bincode::config::{
        AllowTrailing, BigEndian, Bounded, DefaultOptions as BincodeDefaultOptions, FixintEncoding,
        Options as _, WithOtherEndian, WithOtherIntEncoding, WithOtherLimit, WithOtherTrailing,
    };

    pub type Default =
        WithOtherIntEncoding<WithOtherEndian<BincodeDefaultOptions, BigEndian>, FixintEncoding>;

    #[inline]
    pub fn default() -> Default {
        bincode::options().with_big_endian().with_fixint_encoding()
    }

    pub type SP1v4 = WithOtherTrailing<
        WithOtherIntEncoding<BincodeDefaultOptions, FixintEncoding>,
        AllowTrailing,
    >;

    #[inline]
    pub fn sp1v4() -> SP1v4 {
        bincode::options()
            .with_fixint_encoding()
            .allow_trailing_bytes()
    }

    pub type Limited<T> = WithOtherLimit<T, Bounded>;
}

/// Bincode codec with opinionated settings.
#[derive(Clone, Debug)]
pub struct Codec<Opts>(Opts);

/// Create a bincode codec with default agglayer settings.
#[inline]
pub fn default() -> Codec<options::Default> {
    Codec(options::default())
}

/// Create a bincode codec with settings used by `sp1`.
#[inline]
pub fn sp1v4() -> Codec<options::SP1v4> {
    Codec(options::sp1v4())
}

/// Create a bincode coded with settings used by smart contract verifiers.
///
/// This happens to be the same as [default] but with a more accurate name.
#[inline]
pub fn contracts() -> Codec<options::Default> {
    default()
}

impl<Opts: Options> Codec<Opts> {
    /// Impose a limit on encoding / decoding size.
    #[inline]
    pub fn with_limit(self, max: u64) -> Codec<options::Limited<Opts>> {
        Codec(self.0.with_limit(max))
    }

    /// Encode an object into a byte vector.
    #[inline]
    pub fn serialize<T>(self, item: &T) -> Result<Vec<u8>>
    where
        T: ?Sized + serde::Serialize,
    {
        self.0.serialize(item)
    }

    /// Encode an object into a writer.
    #[inline]
    pub fn serialize_into<W, T>(self, writer: W, item: &T) -> Result<()>
    where
        W: std::io::Write,
        T: ?Sized + serde::Serialize,
    {
        self.0.serialize_into(writer, item)
    }

    /// Decode an object from a slice.
    #[inline]
    pub fn deserialize<'a, T>(self, bytes: &'a [u8]) -> Result<T>
    where
        T: serde::Deserialize<'a>,
    {
        self.0.deserialize(bytes)
    }

    /// Decode an object from a reader.
    #[inline]
    pub fn deserialize_from<T, R>(self, reader: R) -> Result<T>
    where
        T: serde::de::DeserializeOwned,
        R: std::io::Read,
    {
        self.0.deserialize_from(reader)
    }
}

#[cfg(test)]
mod test {
    use unified_bridge::NetworkId;

    #[test]
    fn sp1_endians() {
        let network_id = NetworkId::new(0x00112233);
        let network_id_enc = super::sp1v4().serialize(&network_id).unwrap();

        let mut stdin0 = sp1_sdk::SP1Stdin::new();
        stdin0.write_slice(&network_id_enc);

        let mut stdin1 = sp1_sdk::SP1Stdin::new();
        stdin1.write(&network_id);

        assert_eq!(&stdin1.buffer[0], &[0x33, 0x22, 0x11, 0x00]);
        assert_eq!(stdin0.buffer, stdin1.buffer);
        assert_eq!(stdin0.read::<NetworkId>(), stdin1.read::<NetworkId>());
    }
}