scale_serialization/
serializer.rs

1use crate::error::Error;
2use crate::prelude::*;
3use crate::registry::*;
4use bytes::BufMut;
5use core::fmt::Debug;
6
7use serde::{ser, Serialize};
8
9type Result<T> = core::result::Result<T, Error>;
10
11/// SCALE-encode a value into a new `Vec<u8>`.
12#[inline]
13pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
14where
15    T: Serialize + ?Sized,
16{
17    let mut out = vec![];
18    to_bytes(&mut out, value)?;
19    Ok(out)
20}
21
22/// SCALE-encode a value into a new `Vec<u8>`, using type info to coerce representations.
23#[inline]
24pub fn to_vec_with_info<T>(value: &T, registry_type: Option<(&Registry, TypeId)>) -> Result<Vec<u8>>
25where
26    T: Serialize + ?Sized,
27{
28    let mut out = vec![];
29    to_bytes_with_info(&mut out, value, registry_type)?;
30    Ok(out)
31}
32
33/// SCALE-encode a value into an existing buffer.
34pub fn to_bytes<B, T>(bytes: B, value: &T) -> Result<()>
35where
36    T: Serialize + ?Sized,
37    B: BufMut + Debug,
38{
39    to_bytes_with_info(bytes, value, None)
40}
41
42/// SCALE-encode a value into a buffer, using type info to coerce representations.
43pub fn to_bytes_with_info<B, T>(
44    bytes: B,
45    value: &T,
46    registry_type: Option<(&Registry, TypeId)>,
47) -> Result<()>
48where
49    T: Serialize + ?Sized,
50    B: BufMut + Debug,
51{
52    let mut serializer = Serializer::new(bytes, registry_type);
53    value.serialize(&mut serializer)?;
54    Ok(())
55}
56
57/// SCALE-encode a JSON-like key-value iterator into a buffer using type info.
58#[cfg(feature = "json")]
59pub fn to_bytes_from_iter<B, K, V>(
60    bytes: B,
61    iter: impl IntoIterator<Item = (K, V)>,
62    registry_type: (&Registry, TypeId),
63) -> Result<()>
64where
65    B: BufMut + Debug,
66    K: Into<String>,
67    V: Into<crate::JsonValue>,
68{
69    let ty = registry_type
70        .0
71        .resolve(registry_type.1)
72        .ok_or_else(|| Error::BadInput("Type not in registry".into()))?;
73    let obj = iter.into_iter().collect::<crate::JsonValue>();
74    let val: crate::JsonValue = if let TypeDef::Struct(ref fields) = *ty {
75        fields
76            .iter()
77            .map(|f| {
78                Ok((
79                    &*f.name,
80                    obj.get(&f.name)
81                        .ok_or_else(|| Error::BadInput(format!("missing field {}", f.name)))?
82                        .clone(),
83                ))
84            })
85            .collect::<Result<_>>()?
86    } else {
87        return Err(Error::BadType(format!("{:?}", ty)));
88    };
89
90    to_bytes_with_info(bytes, &val, Some(registry_type))
91}
92
93/// Like [`to_bytes_from_iter`] but allocates and returns a `Vec<u8>`.
94#[cfg(feature = "json")]
95pub fn to_vec_from_iter<I, K, V>(iter: I, registry_type: (&Registry, TypeId)) -> Result<Vec<u8>>
96where
97    I: IntoIterator<Item = (K, V)>,
98    K: Into<String>,
99    V: Into<crate::JsonValue>,
100{
101    let mut out = vec![];
102    to_bytes_from_iter(&mut out, iter, registry_type)?;
103    Ok(out)
104}
105
106/// A serializer that encodes types to SCALE with the option to coerce
107/// the output to an equivalent representation given by some type information.
108#[derive(Debug)]
109pub struct Serializer<'reg, B>
110where
111    B: Debug,
112{
113    out: B,
114    ty_id: Option<TypeId>,
115    /// Synthetic type override for cases where no registry TypeId exists (e.g. ByteSeq U8 elements)
116    ty_hint: Option<TypeDef>,
117    registry: Option<&'reg Registry>,
118    picked: Option<usize>,
119}
120
121impl<'reg, B> Serializer<'reg, B>
122where
123    B: BufMut + Debug,
124{
125    pub fn new(out: B, registry_type: Option<(&'reg Registry, TypeId)>) -> Self {
126        let (registry, ty_id) = match registry_type {
127            Some((reg, ty_id)) => (Some(reg), Some(ty_id)),
128            None => (None, None),
129        };
130        Serializer {
131            out,
132            ty_id,
133            ty_hint: None,
134            registry,
135            picked: None,
136        }
137    }
138
139    fn serialize_compact(&mut self, _ty: u32, v: u128) -> Result<()> {
140        crate::compact_encode(v, &mut self.out);
141        Ok(())
142    }
143}
144
145impl<'a, 'reg, B> ser::Serializer for &'a mut Serializer<'reg, B>
146where
147    B: BufMut + Debug,
148{
149    type Ok = ();
150    type Error = Error;
151
152    type SerializeSeq = TypedSerializer<'a, 'reg, B>;
153    type SerializeTuple = TypedSerializer<'a, 'reg, B>;
154    type SerializeTupleStruct = TypedSerializer<'a, 'reg, B>;
155    type SerializeTupleVariant = TypedSerializer<'a, 'reg, B>;
156    type SerializeMap = TypedSerializer<'a, 'reg, B>;
157    type SerializeStruct = TypedSerializer<'a, 'reg, B>;
158    type SerializeStructVariant = TypedSerializer<'a, 'reg, B>;
159
160    fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
161        self.maybe_some()?;
162        self.out.put_u8(v.into());
163        Ok(())
164    }
165
166    fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
167        self.maybe_some()?;
168        self.out.put_i8(v);
169        Ok(())
170    }
171
172    fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
173        self.maybe_some()?;
174        self.out.put_i16_le(v);
175        Ok(())
176    }
177
178    fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
179        self.maybe_some()?;
180        self.out.put_i32_le(v);
181        Ok(())
182    }
183
184    fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
185        match self.ty() {
186            Some(TypeDef::I8) => self.serialize_i8(v as i8)?,
187            Some(TypeDef::I16) => self.serialize_i16(v as i16)?,
188            Some(TypeDef::I32) => self.serialize_i32(v as i32)?,
189            _ => {
190                self.maybe_some()?;
191                self.out.put_i64_le(v)
192            }
193        }
194        Ok(())
195    }
196
197    fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
198        self.maybe_some()?;
199        self.out.put_u8(v);
200        Ok(())
201    }
202
203    fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
204        self.maybe_some()?;
205        self.out.put_u16_le(v);
206        Ok(())
207    }
208
209    fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
210        self.maybe_some()?;
211        self.out.put_u32_le(v);
212        Ok(())
213    }
214
215    fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
216        self.maybe_some()?;
217        // all numbers in serde_json are the same
218        match self.ty() {
219            Some(TypeDef::I8) => self.serialize_i8(v as i8)?,
220            Some(TypeDef::I16) => self.serialize_i16(v as i16)?,
221            Some(TypeDef::I32) => self.serialize_i32(v as i32)?,
222            Some(TypeDef::U8) => self.serialize_u8(v as u8)?,
223            Some(TypeDef::U16) => self.serialize_u16(v as u16)?,
224            Some(TypeDef::U32) => self.serialize_u32(v as u32)?,
225            Some(TypeDef::Compact(ty)) => self.serialize_compact(*ty, v as u128)?,
226            _ => self.out.put_u64_le(v),
227        }
228        Ok(())
229    }
230
231    fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
232        self.maybe_some()?;
233        match self.ty() {
234            Some(TypeDef::I8) => self.serialize_i8(v as i8)?,
235            Some(TypeDef::I16) => self.serialize_i16(v as i16)?,
236            Some(TypeDef::I32) => self.serialize_i32(v as i32)?,
237            Some(TypeDef::I64) => self.serialize_i64(v as i64)?,
238            Some(TypeDef::U8) => self.serialize_u8(v as u8)?,
239            Some(TypeDef::U16) => self.serialize_u16(v as u16)?,
240            Some(TypeDef::U32) => self.serialize_u32(v as u32)?,
241            Some(TypeDef::U64) => self.serialize_u64(v as u64)?,
242            Some(TypeDef::Compact(ty)) => self.serialize_compact(*ty, v)?,
243            _ => self.out.put_u128_le(v),
244        }
245        Ok(())
246    }
247
248    fn serialize_f32(self, _v: f32) -> Result<Self::Ok> {
249        unimplemented!()
250    }
251
252    fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
253        unimplemented!()
254    }
255
256    fn serialize_char(self, _v: char) -> Result<Self::Ok> {
257        unimplemented!()
258    }
259
260    fn serialize_str(self, v: &str) -> Result<Self::Ok> {
261        self.maybe_some()?;
262        if self.maybe_other(v)?.is_some() {
263            return Ok(());
264        }
265
266        compact_number(v.len(), &mut self.out);
267        self.out.put(v.as_bytes());
268        Ok(())
269    }
270
271    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
272        self.maybe_some()?;
273
274        compact_number(v.len(), &mut self.out);
275        self.out.put(v);
276        Ok(())
277    }
278
279    fn serialize_none(self) -> Result<Self::Ok> {
280        self.out.put_u8(0x00);
281        Ok(())
282    }
283
284    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
285    where
286        T: Serialize + ?Sized,
287    {
288        self.out.put_u8(0x01);
289        value.serialize(self)
290    }
291
292    fn serialize_unit(self) -> Result<Self::Ok> {
293        self.maybe_some()?;
294        Ok(())
295    }
296
297    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
298        self.maybe_some()?;
299        Ok(())
300    }
301
302    fn serialize_unit_variant(
303        self,
304        __name: &'static str,
305        variant_index: u32,
306        _variant: &'static str,
307    ) -> Result<Self::Ok> {
308        self.maybe_some()?;
309        (variant_index as u8).serialize(self)
310    }
311
312    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
313    where
314        T: Serialize + ?Sized,
315    {
316        self.maybe_some()?;
317        value.serialize(self)
318    }
319
320    fn serialize_newtype_variant<T>(
321        self,
322        __name: &'static str,
323        variant_index: u32,
324        _variant: &'static str,
325        value: &T,
326    ) -> Result<Self::Ok>
327    where
328        T: Serialize + ?Sized,
329    {
330        self.maybe_some()?;
331        self.out.put_u8(variant_index as u8);
332        value.serialize(self)
333    }
334
335    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
336        self.maybe_some()?;
337        if matches!(
338            self.ty(),
339            None | Some(TypeDef::Bytes) | Some(TypeDef::Sequence(_))
340        ) {
341            compact_number(len.expect("known length"), &mut self.out);
342        }
343        Ok(self.into())
344    }
345
346    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
347        self.maybe_some()?;
348        Ok(self.into())
349    }
350
351    fn serialize_tuple_struct(
352        self,
353        __name: &'static str,
354        __len: usize,
355    ) -> Result<Self::SerializeTupleStruct> {
356        self.maybe_some()?;
357        Ok(self.into())
358    }
359
360    fn serialize_tuple_variant(
361        self,
362        __name: &'static str,
363        variant_index: u32,
364        _variant: &'static str,
365        __len: usize,
366    ) -> Result<Self::SerializeTupleVariant> {
367        self.maybe_some()?;
368        self.out.put_u8(variant_index as u8);
369        Ok(self.into())
370    }
371
372    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
373        self.maybe_some()?;
374        if matches!(self.ty(), None | Some(TypeDef::Map(_, _))) {
375            compact_number(len.expect("known length"), &mut self.out);
376        }
377        Ok(self.into())
378    }
379
380    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
381        self.maybe_some()?;
382        Ok(self.into())
383    }
384
385    fn serialize_struct_variant(
386        self,
387        __name: &'static str,
388        variant_index: u32,
389        _variant: &'static str,
390        __len: usize,
391    ) -> Result<Self::SerializeStructVariant> {
392        self.maybe_some()?;
393        self.out.put_u8(variant_index as u8);
394        Ok(self.into())
395    }
396}
397
398impl<'reg, B: Debug> Serializer<'reg, B> {
399    fn ty(&self) -> Option<&TypeDef> {
400        self.ty_id
401            .map(|id| self.resolve(id) as &TypeDef)
402            .or(self.ty_hint.as_ref())
403    }
404
405    fn resolve(&self, ty_id: TypeId) -> &'reg TypeDef {
406        let reg = self.registry.expect("called having type");
407        reg.resolve(ty_id).expect("in registry")
408    }
409}
410
411impl<'reg, B> Serializer<'reg, B>
412where
413    B: BufMut + Debug,
414{
415    // A check to run for every serialize fn since any type could be an Option::Some
416    // if the type info says its an Option assume its Some and extract the inner type
417    fn maybe_some(&mut self) -> Result<()> {
418        if let Some(ty_id) = self.ty_id {
419            if let TypeDef::Variant(vdef) = self.resolve(ty_id) {
420                if vdef.name == "Option" {
421                    self.ty_id = match &vdef.variants[1].fields {
422                        Fields::NewType(inner) => Some(*inner),
423                        _ => None,
424                    };
425                    self.out.put_u8(0x01);
426                }
427            }
428        }
429        Ok(())
430    }
431
432    #[inline]
433    fn maybe_other(&mut self, val: &str) -> Result<Option<()>> {
434        let ty = match self.ty() {
435            Some(ty) => ty,
436            None => return Ok(None),
437        };
438        match ty {
439            TypeDef::Str => Ok(None),
440            // { "foo": "Bar" } => "Bar" might be an enum variant
441            TypeDef::Variant(vdef) => {
442                let variant = vdef
443                    .variants
444                    .iter()
445                    .find(|v| v.name == val)
446                    .ok_or_else(|| Error::BadInput("Invalid variant".into()))?;
447                self.out.put_u8(variant.index);
448                Ok(Some(()))
449            }
450            TypeDef::StructNewType(ty_id) => match self.resolve(*ty_id) {
451                // { "foo": "bar" } => "bar" might be a string wrapped in a type
452                TypeDef::Str => Ok(None),
453                ty => Err(Error::NotSupported(
454                    type_name_of_val(val),
455                    format!("{:?}", ty),
456                )),
457            },
458            TypeDef::U8 => {
459                let n = val.parse().map_err(|_| Error::BadInput("u8".into()))?;
460                self.out.put_u8(n);
461                Ok(Some(()))
462            }
463            TypeDef::U16 => {
464                let n = val.parse().map_err(|_| Error::BadInput("u16".into()))?;
465                self.out.put_u16_le(n);
466                Ok(Some(()))
467            }
468            TypeDef::U32 => {
469                let n = val.parse().map_err(|_| Error::BadInput("u32".into()))?;
470                self.out.put_u32_le(n);
471                Ok(Some(()))
472            }
473            TypeDef::U64 => {
474                let n = val.parse().map_err(|_| Error::BadInput("u64".into()))?;
475                self.out.put_u64_le(n);
476                Ok(Some(()))
477            }
478            TypeDef::U128 => {
479                let n = val.parse().map_err(|_| Error::BadInput("u128".into()))?;
480                self.out.put_u128_le(n);
481                Ok(Some(()))
482            }
483            TypeDef::I8 => {
484                let n = val.parse().map_err(|_| Error::BadInput("i8".into()))?;
485                self.out.put_i8(n);
486                Ok(Some(()))
487            }
488            TypeDef::I16 => {
489                let n = val.parse().map_err(|_| Error::BadInput("i16".into()))?;
490                self.out.put_i16_le(n);
491                Ok(Some(()))
492            }
493            TypeDef::I32 => {
494                let n = val.parse().map_err(|_| Error::BadInput("i32".into()))?;
495                self.out.put_i32_le(n);
496                Ok(Some(()))
497            }
498            TypeDef::I64 => {
499                let n = val.parse().map_err(|_| Error::BadInput("i64".into()))?;
500                self.out.put_i64_le(n);
501                Ok(Some(()))
502            }
503            TypeDef::I128 => {
504                let n = val.parse().map_err(|_| Error::BadInput("i128".into()))?;
505                self.out.put_i128_le(n);
506                Ok(Some(()))
507            }
508            TypeDef::Bytes => {
509                if let Some(hex) = val.strip_prefix("0x") {
510                    let bytes = crate::decode_hex(hex)?;
511                    ser::Serializer::serialize_bytes(self, &bytes)?;
512                    Ok(Some(()))
513                } else {
514                    Err(Error::BadInput("Hex string must start with 0x".into()))
515                }
516            }
517            ty => Err(Error::NotSupported(
518                type_name_of_val(val),
519                format!("{:?}", ty),
520            )),
521        }
522    }
523}
524
525/// Borrowed field type sources — avoids Vec allocation and O(n) remove(0)
526#[derive(Debug)]
527pub enum FieldTypes<'reg> {
528    Ids(&'reg [TypeId]),
529    Fields(&'reg [Field]),
530}
531
532impl FieldTypes<'_> {
533    fn next(&mut self) -> TypeId {
534        match self {
535            FieldTypes::Ids(ids) => {
536                let (first, rest) = ids.split_first().expect("field available");
537                *ids = rest;
538                *first
539            }
540            FieldTypes::Fields(fields) => {
541                let (first, rest) = fields.split_first().expect("field available");
542                *fields = rest;
543                first.ty
544            }
545        }
546    }
547}
548
549#[derive(Debug)]
550pub enum TypedSerializer<'a, 'reg, B>
551where
552    B: Debug,
553{
554    Empty(&'a mut Serializer<'reg, B>),
555    Composite(&'a mut Serializer<'reg, B>, FieldTypes<'reg>),
556    Sequence(&'a mut Serializer<'reg, B>, TypeId),
557    ByteSeq(&'a mut Serializer<'reg, B>),
558    Enum(&'a mut Serializer<'reg, B>),
559}
560
561impl<'a, 'reg, B: 'a> From<&'a mut Serializer<'reg, B>> for TypedSerializer<'a, 'reg, B>
562where
563    B: Debug,
564{
565    fn from(ser: &'a mut Serializer<'reg, B>) -> Self {
566        let ty_id = match ser.ty_id.take() {
567            Some(id) => id,
568            None => return Self::Empty(ser),
569        };
570        let ty = ser.resolve(ty_id);
571        match ty {
572            TypeDef::Struct(ref fields) => Self::Composite(ser, FieldTypes::Fields(fields)),
573            TypeDef::StructTuple(ref ids) => Self::Composite(ser, FieldTypes::Ids(ids)),
574            TypeDef::Array(ty, _) => Self::Sequence(ser, *ty),
575            TypeDef::Tuple(ref ids) => Self::Composite(ser, FieldTypes::Ids(ids)),
576            TypeDef::Sequence(ty) => Self::Sequence(ser, *ty),
577            TypeDef::Bytes => Self::ByteSeq(ser),
578            TypeDef::Map(_, _) => Self::Empty(ser),
579            TypeDef::Variant(ref vdef) => {
580                if let Some(idx) = ser.picked.take() {
581                    match &vdef.variants[idx].fields {
582                        Fields::Tuple(types) => Self::Composite(ser, FieldTypes::Ids(types)),
583                        Fields::Struct(fields) => Self::Composite(ser, FieldTypes::Fields(fields)),
584                        _ => Self::Empty(ser),
585                    }
586                } else {
587                    ser.ty_id = Some(ty_id);
588                    Self::Enum(ser)
589                }
590            }
591            _ => Self::Empty(ser),
592        }
593    }
594}
595
596impl<'reg, B> TypedSerializer<'_, 'reg, B>
597where
598    B: Debug,
599{
600    fn serializer(&mut self) -> &mut Serializer<'reg, B> {
601        match self {
602            Self::Empty(ser)
603            | Self::Composite(ser, _)
604            | Self::Enum(ser)
605            | Self::Sequence(ser, _)
606            | Self::ByteSeq(ser) => ser,
607        }
608    }
609}
610
611/// Resolve a field type, unwrapping newtypes (serde_json unwraps them)
612fn unwrap_newtype(reg: &Registry, ty_id: TypeId) -> TypeId {
613    match reg.resolve(ty_id).expect("in registry") {
614        TypeDef::StructNewType(inner) => *inner,
615        _ => ty_id,
616    }
617}
618
619impl<B> ser::SerializeMap for TypedSerializer<'_, '_, B>
620where
621    B: BufMut + Debug,
622{
623    type Ok = ();
624    type Error = Error;
625
626    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
627    where
628        T: Serialize + ?Sized,
629    {
630        match self {
631            TypedSerializer::Enum(ser) => {
632                if let Some(ty_id) = ser.ty_id {
633                    if let TypeDef::Variant(vdef) = ser.resolve(ty_id) {
634                        let key_data = to_vec(key)?;
635                        let idx = vdef
636                            .variants
637                            .iter()
638                            .position(|v| to_vec(&v.name).is_ok_and(|d| d == key_data))
639                            .ok_or_else(|| Error::BadInput("Invalid variant".into()))?;
640                        let variant_index = vdef.variants[idx].index;
641                        ser.picked = Some(idx);
642                        variant_index.serialize(&mut **ser)?;
643                    }
644                }
645                Ok(())
646            }
647            TypedSerializer::Empty(ser) => key.serialize(&mut **ser),
648            _ => Ok(()),
649        }
650    }
651
652    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
653    where
654        T: Serialize + ?Sized,
655    {
656        match self {
657            TypedSerializer::Composite(ser, field_types) => {
658                let reg = ser.registry.expect("called having type");
659                ser.ty_id = Some(unwrap_newtype(reg, field_types.next()));
660                ser.ty_hint = None;
661            }
662            TypedSerializer::Enum(ser) => {
663                if let Some(ty_id) = ser.ty_id {
664                    if let TypeDef::Variant(vdef) = ser.resolve(ty_id) {
665                        if let Some(idx) = ser.picked {
666                            if let Fields::NewType(field_ty_id) = &vdef.variants[idx].fields {
667                                let reg = ser.registry.expect("called having type");
668                                ser.ty_id = Some(unwrap_newtype(reg, *field_ty_id));
669                                ser.ty_hint = None;
670                                ser.picked = None;
671                            }
672                        }
673                    }
674                }
675            }
676            _ => {}
677        }
678        value.serialize(self.serializer())
679    }
680
681    fn end(self) -> Result<Self::Ok> {
682        Ok(())
683    }
684}
685
686impl<B> ser::SerializeSeq for TypedSerializer<'_, '_, B>
687where
688    B: BufMut + Debug,
689{
690    type Ok = ();
691    type Error = Error;
692
693    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
694    where
695        T: Serialize + ?Sized,
696    {
697        match self {
698            TypedSerializer::Composite(ser, field_types) => {
699                let reg = ser.registry.expect("called having type");
700                ser.ty_id = Some(unwrap_newtype(reg, field_types.next()));
701                ser.ty_hint = None;
702            }
703            TypedSerializer::Sequence(ser, ty_id) => {
704                let reg = ser.registry.expect("called having type");
705                ser.ty_id = Some(unwrap_newtype(reg, *ty_id));
706                ser.ty_hint = None;
707            }
708            TypedSerializer::ByteSeq(ser) => {
709                ser.ty_id = None;
710                ser.ty_hint = Some(TypeDef::U8);
711            }
712            _ => {}
713        };
714        value.serialize(self.serializer())
715    }
716
717    fn end(self) -> Result<Self::Ok> {
718        Ok(())
719    }
720}
721
722impl<B> ser::SerializeStruct for TypedSerializer<'_, '_, B>
723where
724    B: BufMut + Debug,
725{
726    type Ok = ();
727    type Error = Error;
728
729    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
730    where
731        T: Serialize + ?Sized,
732    {
733        value.serialize(self.serializer())
734    }
735
736    fn end(self) -> Result<Self::Ok> {
737        Ok(())
738    }
739}
740
741impl<B> ser::SerializeStructVariant for TypedSerializer<'_, '_, B>
742where
743    B: BufMut + Debug,
744{
745    type Ok = ();
746    type Error = Error;
747
748    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
749    where
750        T: Serialize + ?Sized,
751    {
752        value.serialize(self.serializer())
753    }
754
755    fn end(self) -> Result<Self::Ok> {
756        Ok(())
757    }
758}
759
760impl<B> ser::SerializeTuple for TypedSerializer<'_, '_, B>
761where
762    B: BufMut + Debug,
763{
764    type Ok = ();
765    type Error = Error;
766
767    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
768    where
769        T: Serialize + ?Sized,
770    {
771        value.serialize(self.serializer())
772    }
773
774    fn end(self) -> Result<Self::Ok> {
775        Ok(())
776    }
777}
778
779impl<B> ser::SerializeTupleStruct for TypedSerializer<'_, '_, B>
780where
781    B: BufMut + Debug,
782{
783    type Ok = ();
784    type Error = Error;
785
786    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
787    where
788        T: Serialize + ?Sized,
789    {
790        value.serialize(self.serializer())
791    }
792
793    fn end(self) -> Result<Self::Ok> {
794        Ok(())
795    }
796}
797
798impl<B> ser::SerializeTupleVariant for TypedSerializer<'_, '_, B>
799where
800    B: BufMut + Debug,
801{
802    type Ok = ();
803    type Error = Error;
804
805    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
806    where
807        T: Serialize + ?Sized,
808    {
809        value.serialize(self.serializer())
810    }
811
812    fn end(self) -> Result<Self::Ok> {
813        Ok(())
814    }
815}
816
817fn compact_number(n: usize, dest: impl BufMut) {
818    crate::compact_encode(n as u128, dest)
819}
820
821// nightly only
822fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str {
823    core::any::type_name::<T>()
824}
scale_serialization/serializer.rs

scale_serialization/
serializer.rs
