miden_serde_utils/
lib.rs

1// Copyright (c) Facebook, Inc. and its affiliates.
2//
3// This source code is licensed under the MIT license found in the
4// LICENSE file in the root directory of this source tree.
5
6#![cfg_attr(not(feature = "std"), no_std)]
7
8extern crate alloc;
9
10use alloc::{
11    collections::{BTreeMap, BTreeSet},
12    format,
13    string::String,
14    sync::Arc,
15    vec::Vec,
16};
17use core::mem::size_of;
18
19/// Deserializes a wincode schema and rejects trailing bytes.
20///
21/// Unlike `wincode::config::deserialize_exact`, this accepts schema adapters whose decoded type
22/// differs from the schema type.
23pub fn deserialize_schema_exact<'de, T, C>(
24    mut bytes: &'de [u8],
25    _config: C,
26) -> wincode::ReadResult<T::Dst>
27where
28    T: wincode::SchemaRead<'de, C>,
29    C: wincode::config::Config,
30{
31    use wincode::io::Reader as _;
32
33    let value = T::get(bytes.by_ref())?;
34    if bytes.is_empty() {
35        Ok(value)
36    } else {
37        Err(wincode::error::trailing_bytes())
38    }
39}
40
41#[cfg(test)]
42mod wincode_tests {
43    use serde_wincode::SerdeCompat;
44
45    use super::deserialize_schema_exact;
46
47    #[test]
48    fn exact_deserialization_rejects_trailing_bytes() {
49        let config = wincode::config::Configuration::default();
50        let mut bytes =
51            <SerdeCompat<u8> as wincode::config::Serialize<_>>::serialize(&7, config).unwrap();
52
53        assert_eq!(deserialize_schema_exact::<SerdeCompat<u8>, _>(&bytes, config).unwrap(), 7);
54
55        bytes.push(0);
56        assert!(matches!(
57            deserialize_schema_exact::<SerdeCompat<u8>, _>(&bytes, config),
58            Err(wincode::error::ReadError::TrailingBytes)
59        ));
60    }
61}
62
63// ERROR
64// ================================================================================================
65
66/// Defines errors which can occur during deserialization.
67#[derive(Clone, Debug, PartialEq, Eq)]
68pub enum DeserializationError {
69    /// Indicates that the deserialization failed because of insufficient data.
70    UnexpectedEOF,
71    /// Indicates that the deserialization failed because the value was not valid.
72    InvalidValue(String),
73    /// Indicates that deserialization failed for an unknown reason.
74    UnknownError(String),
75}
76
77impl core::error::Error for DeserializationError {}
78
79impl core::fmt::Display for DeserializationError {
80    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
81        match self {
82            Self::UnexpectedEOF => write!(f, "unexpected end of file"),
83            Self::InvalidValue(msg) => write!(f, "invalid value: {msg}"),
84            Self::UnknownError(msg) => write!(f, "unknown error: {msg}"),
85        }
86    }
87}
88
89mod byte_reader;
90#[cfg(feature = "std")]
91pub use byte_reader::ReadAdapter;
92pub use byte_reader::{BudgetedReader, ByteReader, ReadManyIter, SliceReader};
93
94mod byte_writer;
95pub use byte_writer::ByteWriter;
96
97// SERIALIZABLE TRAIT
98// ================================================================================================
99
100/// Defines how to serialize `Self` into bytes.
101pub trait Serializable {
102    // REQUIRED METHODS
103    // --------------------------------------------------------------------------------------------
104    /// Serializes `self` into bytes and writes these bytes into the `target`.
105    fn write_into<W: ByteWriter>(&self, target: &mut W);
106
107    // PROVIDED METHODS
108    // --------------------------------------------------------------------------------------------
109
110    /// Serializes `self` into a vector of bytes.
111    fn to_bytes(&self) -> Vec<u8> {
112        let mut result = Vec::with_capacity(self.get_size_hint());
113        self.write_into(&mut result);
114        result
115    }
116
117    /// Returns an estimate of how many bytes are needed to represent self.
118    ///
119    /// The default implementation returns zero.
120    fn get_size_hint(&self) -> usize {
121        0
122    }
123}
124
125impl<T: Serializable> Serializable for &T {
126    fn write_into<W: ByteWriter>(&self, target: &mut W) {
127        (*self).write_into(target)
128    }
129
130    fn get_size_hint(&self) -> usize {
131        (*self).get_size_hint()
132    }
133}
134
135impl Serializable for () {
136    fn write_into<W: ByteWriter>(&self, _target: &mut W) {}
137
138    fn get_size_hint(&self) -> usize {
139        0
140    }
141}
142
143impl<T1> Serializable for (T1,)
144where
145    T1: Serializable,
146{
147    fn write_into<W: ByteWriter>(&self, target: &mut W) {
148        self.0.write_into(target);
149    }
150
151    fn get_size_hint(&self) -> usize {
152        self.0.get_size_hint()
153    }
154}
155
156impl<T1, T2> Serializable for (T1, T2)
157where
158    T1: Serializable,
159    T2: Serializable,
160{
161    fn write_into<W: ByteWriter>(&self, target: &mut W) {
162        self.0.write_into(target);
163        self.1.write_into(target);
164    }
165
166    fn get_size_hint(&self) -> usize {
167        self.0.get_size_hint() + self.1.get_size_hint()
168    }
169}
170
171impl<T1, T2, T3> Serializable for (T1, T2, T3)
172where
173    T1: Serializable,
174    T2: Serializable,
175    T3: Serializable,
176{
177    fn write_into<W: ByteWriter>(&self, target: &mut W) {
178        self.0.write_into(target);
179        self.1.write_into(target);
180        self.2.write_into(target);
181    }
182
183    fn get_size_hint(&self) -> usize {
184        self.0.get_size_hint() + self.1.get_size_hint() + self.2.get_size_hint()
185    }
186}
187
188impl<T1, T2, T3, T4> Serializable for (T1, T2, T3, T4)
189where
190    T1: Serializable,
191    T2: Serializable,
192    T3: Serializable,
193    T4: Serializable,
194{
195    fn write_into<W: ByteWriter>(&self, target: &mut W) {
196        self.0.write_into(target);
197        self.1.write_into(target);
198        self.2.write_into(target);
199        self.3.write_into(target);
200    }
201
202    fn get_size_hint(&self) -> usize {
203        self.0.get_size_hint()
204            + self.1.get_size_hint()
205            + self.2.get_size_hint()
206            + self.3.get_size_hint()
207    }
208}
209
210impl<T1, T2, T3, T4, T5> Serializable for (T1, T2, T3, T4, T5)
211where
212    T1: Serializable,
213    T2: Serializable,
214    T3: Serializable,
215    T4: Serializable,
216    T5: Serializable,
217{
218    fn write_into<W: ByteWriter>(&self, target: &mut W) {
219        self.0.write_into(target);
220        self.1.write_into(target);
221        self.2.write_into(target);
222        self.3.write_into(target);
223        self.4.write_into(target);
224    }
225
226    fn get_size_hint(&self) -> usize {
227        self.0.get_size_hint()
228            + self.1.get_size_hint()
229            + self.2.get_size_hint()
230            + self.3.get_size_hint()
231            + self.4.get_size_hint()
232    }
233}
234
235impl<T1, T2, T3, T4, T5, T6> Serializable for (T1, T2, T3, T4, T5, T6)
236where
237    T1: Serializable,
238    T2: Serializable,
239    T3: Serializable,
240    T4: Serializable,
241    T5: Serializable,
242    T6: Serializable,
243{
244    fn write_into<W: ByteWriter>(&self, target: &mut W) {
245        self.0.write_into(target);
246        self.1.write_into(target);
247        self.2.write_into(target);
248        self.3.write_into(target);
249        self.4.write_into(target);
250        self.5.write_into(target);
251    }
252
253    fn get_size_hint(&self) -> usize {
254        self.0.get_size_hint()
255            + self.1.get_size_hint()
256            + self.2.get_size_hint()
257            + self.3.get_size_hint()
258            + self.4.get_size_hint()
259            + self.5.get_size_hint()
260    }
261}
262
263impl Serializable for u8 {
264    fn write_into<W: ByteWriter>(&self, target: &mut W) {
265        target.write_u8(*self);
266    }
267
268    fn get_size_hint(&self) -> usize {
269        size_of::<u8>()
270    }
271}
272
273impl Serializable for u16 {
274    fn write_into<W: ByteWriter>(&self, target: &mut W) {
275        target.write_u16(*self);
276    }
277
278    fn get_size_hint(&self) -> usize {
279        size_of::<u16>()
280    }
281}
282
283impl Serializable for u32 {
284    fn write_into<W: ByteWriter>(&self, target: &mut W) {
285        target.write_u32(*self);
286    }
287
288    fn get_size_hint(&self) -> usize {
289        size_of::<u32>()
290    }
291}
292
293impl Serializable for u64 {
294    fn write_into<W: ByteWriter>(&self, target: &mut W) {
295        target.write_u64(*self);
296    }
297
298    fn get_size_hint(&self) -> usize {
299        size_of::<u64>()
300    }
301}
302
303impl Serializable for u128 {
304    fn write_into<W: ByteWriter>(&self, target: &mut W) {
305        target.write_u128(*self);
306    }
307
308    fn get_size_hint(&self) -> usize {
309        size_of::<u128>()
310    }
311}
312
313impl Serializable for usize {
314    fn write_into<W: ByteWriter>(&self, target: &mut W) {
315        target.write_usize(*self)
316    }
317
318    fn get_size_hint(&self) -> usize {
319        byte_writer::usize_encoded_len(*self as u64)
320    }
321}
322
323impl<T: Serializable> Serializable for Option<T> {
324    fn write_into<W: ByteWriter>(&self, target: &mut W) {
325        match self {
326            Some(v) => {
327                target.write_bool(true);
328                v.write_into(target);
329            },
330            None => target.write_bool(false),
331        }
332    }
333
334    fn get_size_hint(&self) -> usize {
335        size_of::<bool>() + self.as_ref().map(Serializable::get_size_hint).unwrap_or(0)
336    }
337}
338
339impl<T: Serializable, const C: usize> Serializable for [T; C] {
340    fn write_into<W: ByteWriter>(&self, target: &mut W) {
341        target.write_many(self)
342    }
343
344    fn get_size_hint(&self) -> usize {
345        let mut size = 0;
346        for item in self {
347            size += item.get_size_hint();
348        }
349        size
350    }
351}
352
353impl<T: Serializable> Serializable for [T] {
354    fn write_into<W: ByteWriter>(&self, target: &mut W) {
355        target.write_usize(self.len());
356        for element in self.iter() {
357            element.write_into(target);
358        }
359    }
360
361    fn get_size_hint(&self) -> usize {
362        let mut size = self.len().get_size_hint();
363        for element in self {
364            size += element.get_size_hint();
365        }
366        size
367    }
368}
369
370impl<T: Serializable> Serializable for Vec<T> {
371    fn write_into<W: ByteWriter>(&self, target: &mut W) {
372        target.write_usize(self.len());
373        target.write_many(self);
374    }
375
376    fn get_size_hint(&self) -> usize {
377        let mut size = self.len().get_size_hint();
378        for item in self {
379            size += item.get_size_hint();
380        }
381        size
382    }
383}
384
385impl<K: Serializable, V: Serializable> Serializable for BTreeMap<K, V> {
386    fn write_into<W: ByteWriter>(&self, target: &mut W) {
387        target.write_usize(self.len());
388        target.write_many(self);
389    }
390
391    fn get_size_hint(&self) -> usize {
392        let mut size = self.len().get_size_hint();
393        for item in self {
394            size += item.get_size_hint();
395        }
396        size
397    }
398}
399
400impl<T: Serializable> Serializable for BTreeSet<T> {
401    fn write_into<W: ByteWriter>(&self, target: &mut W) {
402        target.write_usize(self.len());
403        target.write_many(self);
404    }
405
406    fn get_size_hint(&self) -> usize {
407        let mut size = self.len().get_size_hint();
408        for item in self {
409            size += item.get_size_hint();
410        }
411        size
412    }
413}
414
415impl Serializable for str {
416    fn write_into<W: ByteWriter>(&self, target: &mut W) {
417        target.write_usize(self.len());
418        target.write_many(self.as_bytes());
419    }
420
421    fn get_size_hint(&self) -> usize {
422        self.len().get_size_hint() + self.len()
423    }
424}
425
426impl Serializable for String {
427    fn write_into<W: ByteWriter>(&self, target: &mut W) {
428        self.as_str().write_into(target);
429    }
430
431    fn get_size_hint(&self) -> usize {
432        self.as_str().get_size_hint()
433    }
434}
435
436impl Serializable for Arc<str> {
437    fn write_into<W: ByteWriter>(&self, target: &mut W) {
438        self.as_ref().write_into(target);
439    }
440
441    fn get_size_hint(&self) -> usize {
442        self.as_ref().get_size_hint()
443    }
444}
445
446// DESERIALIZABLE
447// ================================================================================================
448
449/// Defines how to deserialize `Self` from bytes.
450pub trait Deserializable: Sized {
451    // REQUIRED METHODS
452    // --------------------------------------------------------------------------------------------
453
454    /// Reads a sequence of bytes from the provided `source`, attempts to deserialize these bytes
455    /// into `Self`, and returns the result.
456    ///
457    /// # Errors
458    /// Returns an error if:
459    /// * The `source` does not contain enough bytes to deserialize `Self`.
460    /// * Bytes read from the `source` do not represent a valid value for `Self`.
461    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError>;
462
463    /// Returns the minimum serialized size for one instance of this type.
464    ///
465    /// This is used by [`ByteReader::max_alloc`] to estimate how many elements can be
466    /// deserialized from the remaining budget, preventing denial-of-service attacks from
467    /// malicious length prefixes.
468    ///
469    /// The default implementation returns `size_of::<Self>()`, which is conservative: it may
470    /// reject valid input for types where the serialized size is smaller than the in-memory
471    /// size (e.g., structs with computed/cached fields that aren't serialized).
472    ///
473    /// Override this method for types where the serialized representation is smaller than
474    /// the in-memory representation to allow more elements to be deserialized.
475    fn min_serialized_size() -> usize {
476        size_of::<Self>()
477    }
478
479    // PROVIDED METHODS
480    // --------------------------------------------------------------------------------------------
481
482    /// Attempts to deserialize the provided `bytes` into `Self` and returns the result.
483    ///
484    /// # Errors
485    /// Returns an error if:
486    /// * The `bytes` do not contain enough information to deserialize `Self`.
487    /// * The `bytes` do not represent a valid value for `Self`.
488    ///
489    /// Note: if `bytes` contains more data than needed to deserialize `self`, no error is
490    /// returned.
491    ///
492    /// # Security
493    /// This method is for trusted input. It does not bound allocations or reject trailing bytes.
494    /// Use [`Deserializable::read_from_bytes_with_budget`] for attacker-controlled bytes.
495    fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError> {
496        Self::read_from(&mut SliceReader::new(bytes))
497    }
498
499    /// Deserializes `Self` from bytes with a byte budget limit.
500    ///
501    /// This is the recommended method for deserializing untrusted input. The budget limits
502    /// how many bytes can be consumed during deserialization, preventing denial-of-service
503    /// attacks that exploit length fields to cause huge allocations.
504    ///
505    /// # Errors
506    /// Returns an error if:
507    /// * The budget is exhausted before deserialization completes.
508    /// * The `bytes` do not contain enough information to deserialize `Self`.
509    /// * The `bytes` do not represent a valid value for `Self`.
510    fn read_from_bytes_with_budget(
511        bytes: &[u8],
512        budget: usize,
513    ) -> Result<Self, DeserializationError> {
514        Self::read_from(&mut BudgetedReader::new(SliceReader::new(bytes), budget))
515    }
516}
517
518impl Deserializable for () {
519    fn read_from<R: ByteReader>(_source: &mut R) -> Result<Self, DeserializationError> {
520        Ok(())
521    }
522}
523
524impl<T1> Deserializable for (T1,)
525where
526    T1: Deserializable,
527{
528    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
529        let v1 = T1::read_from(source)?;
530        Ok((v1,))
531    }
532
533    fn min_serialized_size() -> usize {
534        T1::min_serialized_size()
535    }
536}
537
538impl<T1, T2> Deserializable for (T1, T2)
539where
540    T1: Deserializable,
541    T2: Deserializable,
542{
543    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
544        let v1 = T1::read_from(source)?;
545        let v2 = T2::read_from(source)?;
546        Ok((v1, v2))
547    }
548
549    fn min_serialized_size() -> usize {
550        T1::min_serialized_size().saturating_add(T2::min_serialized_size())
551    }
552}
553
554impl<T1, T2, T3> Deserializable for (T1, T2, T3)
555where
556    T1: Deserializable,
557    T2: Deserializable,
558    T3: Deserializable,
559{
560    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
561        let v1 = T1::read_from(source)?;
562        let v2 = T2::read_from(source)?;
563        let v3 = T3::read_from(source)?;
564        Ok((v1, v2, v3))
565    }
566
567    fn min_serialized_size() -> usize {
568        T1::min_serialized_size()
569            .saturating_add(T2::min_serialized_size())
570            .saturating_add(T3::min_serialized_size())
571    }
572}
573
574impl<T1, T2, T3, T4> Deserializable for (T1, T2, T3, T4)
575where
576    T1: Deserializable,
577    T2: Deserializable,
578    T3: Deserializable,
579    T4: Deserializable,
580{
581    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
582        let v1 = T1::read_from(source)?;
583        let v2 = T2::read_from(source)?;
584        let v3 = T3::read_from(source)?;
585        let v4 = T4::read_from(source)?;
586        Ok((v1, v2, v3, v4))
587    }
588
589    fn min_serialized_size() -> usize {
590        T1::min_serialized_size()
591            .saturating_add(T2::min_serialized_size())
592            .saturating_add(T3::min_serialized_size())
593            .saturating_add(T4::min_serialized_size())
594    }
595}
596
597impl<T1, T2, T3, T4, T5> Deserializable for (T1, T2, T3, T4, T5)
598where
599    T1: Deserializable,
600    T2: Deserializable,
601    T3: Deserializable,
602    T4: Deserializable,
603    T5: Deserializable,
604{
605    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
606        let v1 = T1::read_from(source)?;
607        let v2 = T2::read_from(source)?;
608        let v3 = T3::read_from(source)?;
609        let v4 = T4::read_from(source)?;
610        let v5 = T5::read_from(source)?;
611        Ok((v1, v2, v3, v4, v5))
612    }
613
614    fn min_serialized_size() -> usize {
615        T1::min_serialized_size()
616            .saturating_add(T2::min_serialized_size())
617            .saturating_add(T3::min_serialized_size())
618            .saturating_add(T4::min_serialized_size())
619            .saturating_add(T5::min_serialized_size())
620    }
621}
622
623impl<T1, T2, T3, T4, T5, T6> Deserializable for (T1, T2, T3, T4, T5, T6)
624where
625    T1: Deserializable,
626    T2: Deserializable,
627    T3: Deserializable,
628    T4: Deserializable,
629    T5: Deserializable,
630    T6: Deserializable,
631{
632    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
633        let v1 = T1::read_from(source)?;
634        let v2 = T2::read_from(source)?;
635        let v3 = T3::read_from(source)?;
636        let v4 = T4::read_from(source)?;
637        let v5 = T5::read_from(source)?;
638        let v6 = T6::read_from(source)?;
639        Ok((v1, v2, v3, v4, v5, v6))
640    }
641
642    fn min_serialized_size() -> usize {
643        T1::min_serialized_size()
644            .saturating_add(T2::min_serialized_size())
645            .saturating_add(T3::min_serialized_size())
646            .saturating_add(T4::min_serialized_size())
647            .saturating_add(T5::min_serialized_size())
648            .saturating_add(T6::min_serialized_size())
649    }
650}
651
652impl Deserializable for u8 {
653    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
654        source.read_u8()
655    }
656}
657
658impl Deserializable for u16 {
659    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
660        source.read_u16()
661    }
662}
663
664impl Deserializable for u32 {
665    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
666        source.read_u32()
667    }
668}
669
670impl Deserializable for u64 {
671    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
672        source.read_u64()
673    }
674}
675
676impl Deserializable for u128 {
677    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
678        source.read_u128()
679    }
680}
681
682impl Deserializable for usize {
683    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
684        source.read_usize()
685    }
686
687    fn min_serialized_size() -> usize {
688        1 // vint64 encoding: minimum 1 byte for values 0-127
689    }
690}
691
692impl<T: Deserializable> Deserializable for Option<T> {
693    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
694        if source.read_bool()? {
695            Ok(Some(T::read_from(source)?))
696        } else {
697            Ok(None)
698        }
699    }
700
701    /// Returns 1 (just the bool discriminator).
702    ///
703    /// The `Some` variant would be `1 + T::min_serialized_size()`, but we use the minimum
704    /// to allow more elements through the early check.
705    fn min_serialized_size() -> usize {
706        1
707    }
708}
709
710impl<T: Deserializable, const C: usize> Deserializable for [T; C] {
711    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
712        let data: Vec<T> = source.read_many_iter(C)?.collect::<Result<_, _>>()?;
713
714        // The iterator yields exactly C elements (or fails early), so this always succeeds
715        Ok(data.try_into().unwrap_or_else(|v: Vec<T>| {
716            panic!("Expected a Vec of length {} but it was {}", C, v.len())
717        }))
718    }
719
720    fn min_serialized_size() -> usize {
721        C.saturating_mul(T::min_serialized_size())
722    }
723}
724
725impl<T: Deserializable> Deserializable for Vec<T> {
726    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
727        let len = source.read_usize()?;
728        source.read_many_iter(len)?.collect()
729    }
730
731    /// Returns 1 (the minimum vint length prefix size).
732    ///
733    /// The actual serialized size depends on the number of elements, which we don't know
734    /// at the point this is called. Using the minimum allows more elements through the
735    /// early check; budget enforcement during actual reads provides the real protection.
736    fn min_serialized_size() -> usize {
737        1
738    }
739}
740
741impl<K: Deserializable + Ord, V: Deserializable> Deserializable for BTreeMap<K, V> {
742    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
743        let len = source.read_usize()?;
744        let mut map = BTreeMap::new();
745        for entry in source.read_many_iter(len)? {
746            let (key, value) = entry?;
747            if map.insert(key, value).is_some() {
748                return Err(DeserializationError::InvalidValue(String::from(
749                    "duplicate key in BTreeMap encoding",
750                )));
751            }
752        }
753        Ok(map)
754    }
755
756    fn min_serialized_size() -> usize {
757        1 // minimum vint length prefix
758    }
759}
760
761impl<T: Deserializable + Ord> Deserializable for BTreeSet<T> {
762    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
763        let len = source.read_usize()?;
764        let mut set = BTreeSet::new();
765        for item in source.read_many_iter(len)? {
766            if !set.insert(item?) {
767                return Err(DeserializationError::InvalidValue(String::from(
768                    "duplicate item in BTreeSet encoding",
769                )));
770            }
771        }
772        Ok(set)
773    }
774
775    fn min_serialized_size() -> usize {
776        1 // minimum vint length prefix
777    }
778}
779
780impl Deserializable for String {
781    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
782        let len = source.read_usize()?;
783        let data: Vec<u8> = source.read_many_iter(len)?.collect::<Result<_, _>>()?;
784
785        String::from_utf8(data).map_err(|err| DeserializationError::InvalidValue(format!("{err}")))
786    }
787
788    fn min_serialized_size() -> usize {
789        1 // minimum vint length prefix
790    }
791}
792
793impl Deserializable for Arc<str> {
794    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
795        String::read_from(source).map(Arc::from)
796    }
797
798    fn min_serialized_size() -> usize {
799        1 // minimum vint length prefix
800    }
801}
802
803// GOLDILOCKS FIELD ELEMENT IMPLEMENTATIONS
804// ================================================================================================
805
806impl Serializable for p3_goldilocks::Goldilocks {
807    fn write_into<W: ByteWriter>(&self, target: &mut W) {
808        use p3_field::PrimeField64;
809        target.write_u64(self.as_canonical_u64());
810    }
811
812    fn get_size_hint(&self) -> usize {
813        size_of::<u64>()
814    }
815}
816
817impl Deserializable for p3_goldilocks::Goldilocks {
818    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
819        use p3_field::integers::QuotientMap;
820
821        let value = source.read_u64()?;
822        Self::from_canonical_checked(value).ok_or_else(|| {
823            DeserializationError::InvalidValue(format!(
824                "value {value} is not a valid Goldilocks field element"
825            ))
826        })
827    }
828}
829
830#[cfg(test)]
831mod tests {
832    use alloc::sync::Arc;
833
834    use super::*;
835
836    #[test]
837    fn arc_str_roundtrip() {
838        let original: Arc<str> = Arc::from("hello world");
839        let bytes = original.to_bytes();
840        let deserialized = Arc::<str>::read_from_bytes(&bytes).unwrap();
841        assert_eq!(original, deserialized);
842    }
843
844    #[test]
845    fn string_roundtrip() {
846        let original = String::from("hello world");
847        let bytes = original.to_bytes();
848        let deserialized = String::read_from_bytes(&bytes).unwrap();
849        assert_eq!(original, deserialized);
850    }
851
852    #[test]
853    fn empty_string_roundtrip() {
854        let arc: Arc<str> = Arc::from("");
855        let bytes = arc.to_bytes();
856        let deserialized = Arc::<str>::read_from_bytes(&bytes).unwrap();
857        assert_eq!(deserialized, Arc::from(""));
858
859        let string = String::from("");
860        let bytes = string.to_bytes();
861        let deserialized = String::read_from_bytes(&bytes).unwrap();
862        assert_eq!(deserialized, "");
863    }
864
865    #[test]
866    fn multibyte_utf8_roundtrip() {
867        let text = "héllo 🌍";
868
869        let arc: Arc<str> = Arc::from(text);
870        let bytes = arc.to_bytes();
871        let deserialized = Arc::<str>::read_from_bytes(&bytes).unwrap();
872        assert_eq!(&*deserialized, text);
873
874        let string = String::from(text);
875        let bytes = string.to_bytes();
876        let deserialized = String::read_from_bytes(&bytes).unwrap();
877        assert_eq!(deserialized, text);
878
879        // Cross-compat: Arc<str> bytes can be read as String and vice versa
880        let arc_bytes = Arc::<str>::from(text).to_bytes();
881        let string_bytes = String::from(text).to_bytes();
882        assert_eq!(arc_bytes, string_bytes);
883        assert_eq!(String::read_from_bytes(&arc_bytes).unwrap(), text);
884        assert_eq!(&*Arc::<str>::read_from_bytes(&string_bytes).unwrap(), text);
885    }
886
887    #[test]
888    fn arc_str_string_cross_compat() {
889        // Arc<str> -> bytes -> String
890        let arc: Arc<str> = Arc::from("cross type");
891        let bytes = arc.to_bytes();
892        let as_string = String::read_from_bytes(&bytes).unwrap();
893        assert_eq!(as_string, "cross type");
894
895        // String -> bytes -> Arc<str>
896        let string = String::from("other direction");
897        let bytes = string.to_bytes();
898        let as_arc = Arc::<str>::read_from_bytes(&bytes).unwrap();
899        assert_eq!(&*as_arc, "other direction");
900    }
901
902    #[test]
903    fn btree_map_rejects_duplicate_keys() {
904        let mut bytes = Vec::new();
905        bytes.extend_from_slice(&2usize.to_bytes());
906        bytes.extend_from_slice(&7u8.to_bytes());
907        bytes.extend_from_slice(&1u8.to_bytes());
908        bytes.extend_from_slice(&7u8.to_bytes());
909        bytes.extend_from_slice(&2u8.to_bytes());
910
911        let result = BTreeMap::<u8, u8>::read_from_bytes(&bytes);
912
913        assert!(matches!(result, Err(DeserializationError::InvalidValue(_))));
914    }
915
916    #[test]
917    fn btree_set_rejects_duplicate_items() {
918        let mut bytes = Vec::new();
919        bytes.extend_from_slice(&2usize.to_bytes());
920        bytes.extend_from_slice(&7u8.to_bytes());
921        bytes.extend_from_slice(&7u8.to_bytes());
922
923        let result = BTreeSet::<u8>::read_from_bytes(&bytes);
924
925        assert!(matches!(result, Err(DeserializationError::InvalidValue(_))));
926    }
927
928    #[test]
929    fn budgeted_vec_of_one_element_tuples_accepts_exact_budget() {
930        let values = Vec::<(usize,)>::from([(0,), (1,), (2,)]);
931        let bytes = values.to_bytes();
932
933        let decoded = Vec::<(usize,)>::read_from_bytes_with_budget(&bytes, bytes.len()).unwrap();
934
935        assert_eq!(decoded, values);
936    }
937}
miden_serde_utils/lib.rs

miden_serde_utils/
lib.rs
