cser/
imp.rs

1use super::{
2    error::Error,
3    read_writer::{Reader, Writer},
4    Decodable, Encodable, U56,
5};
6use bytes::Bytes;
7use std::any::Any;
8
9impl Encodable for u8 {
10    fn encode(&self, out: &mut Writer) {
11        out.bytes_w.write(&[*self])
12    }
13}
14
15impl Decodable for u8 {
16    type Error = Error;
17
18    fn decode(buf: &mut Reader<'_>) -> anyhow::Result<Self, Self::Error> {
19        buf.bytes_r.read_byte()
20    }
21}
22
23impl Encodable for bool {
24    fn encode(&self, out: &mut Writer) {
25        out.bits_w.write(1, usize::from(*self))
26    }
27}
28
29impl Decodable for bool {
30    type Error = Error;
31
32    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
33        Ok(u8::try_from(buf.bits_r.read(1)).map_err(|_| Error::OverFlowError)? != 0)
34    }
35}
36
37impl Encodable for u16 {
38    fn encode(&self, out: &mut Writer) {
39        out.write_u64_bits(1, 1, (*self).into())
40    }
41}
42
43impl Decodable for u16 {
44    type Error = Error;
45
46    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
47        buf.read_u64_bits(1, 1)?
48            .try_into()
49            .map_err(|_| Error::OverFlowError)
50    }
51}
52
53impl Encodable for u32 {
54    fn encode(&self, out: &mut Writer) {
55        out.write_u64_bits(1, 2, (*self).into())
56    }
57}
58
59impl Decodable for u32 {
60    type Error = Error;
61
62    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
63        buf.read_u64_bits(1, 2)?
64            .try_into()
65            .map_err(|_| Error::OverFlowError)
66    }
67}
68
69impl Encodable for u64 {
70    fn encode(&self, out: &mut Writer) {
71        out.write_u64_bits(1, 3, *self)
72    }
73}
74
75impl Decodable for u64 {
76    type Error = Error;
77
78    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
79        buf.read_u64_bits(1, 3)
80    }
81}
82
83impl Encodable for i64 {
84    fn encode(&self, out: &mut Writer) {
85        (*self < 0).encode(out);
86        self.unsigned_abs().encode(out);
87    }
88}
89
90impl Decodable for i64 {
91    type Error = Error;
92
93    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
94        let neg = bool::decode(buf)?;
95        let abs = u64::decode(buf)?;
96        if neg && abs == 0 {
97            return Err(Error::NonCanonicalEncoding);
98        }
99        let mut v = 0_i64.overflowing_add_unsigned(abs).0;
100        if neg {
101            v = v.overflowing_neg().0;
102        }
103        Ok(v)
104    }
105}
106
107impl Encodable for U56 {
108    fn encode(&self, out: &mut Writer) {
109        out.write_u64_bits(0, 3, **self)
110    }
111}
112
113impl Decodable for U56 {
114    type Error = Error;
115
116    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
117        U56::try_from(buf.read_u64_bits(0, 3)?).map_err(|_| Error::OverFlowError)
118    }
119}
120
121impl<T> Encodable for Option<T>
122where
123    T: Encodable,
124{
125    fn encode(&self, out: &mut Writer) {
126        if let Some(v) = self {
127            Encodable::encode(&true, out);
128            Encodable::encode(&v, out);
129        } else {
130            Encodable::encode(&false, out);
131        }
132    }
133}
134
135impl<T> Decodable for Option<T>
136where
137    T: Decodable,
138    T::Error: From<Error>,
139{
140    type Error = T::Error;
141
142    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error>
143    where
144        Self: Sized,
145    {
146        let is_some = Decodable::decode(buf)?;
147
148        Ok(if is_some {
149            Some(<T as Decodable>::decode(buf)?)
150        } else {
151            None
152        })
153    }
154}
155
156impl Encodable for &[u8] {
157    fn encode(&self, out: &mut Writer) {
158        U56::try_from(u64::try_from(self.len()).unwrap())
159            .unwrap()
160            .encode(out);
161        out.bytes_w.write(self)
162    }
163}
164
165impl Encodable for Bytes {
166    fn encode(&self, out: &mut Writer) {
167        (&**self).encode(out)
168    }
169}
170
171impl Decodable for Bytes {
172    type Error = Error;
173
174    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
175        let len = U56::decode(buf)?
176            .0
177            .try_into()
178            .map_err(|_| Error::OverFlowError)?;
179
180        Ok(Bytes::copy_from_slice(buf.bytes_r.read(len)?))
181    }
182}
183
184impl<T> Encodable for Vec<T>
185where
186    T: Encodable + 'static,
187{
188    fn encode(&self, out: &mut Writer) {
189        if let Some(s) = <dyn Any>::downcast_ref::<Vec<u8>>(self) {
190            s.as_slice().encode(out)
191        } else {
192            u32::try_from(self.len()).unwrap().encode(out);
193            for item in self {
194                item.encode(out)
195            }
196        }
197    }
198}
199
200impl<T> Decodable for Vec<T>
201where
202    T: Decodable + 'static,
203    T::Error: From<Error>,
204{
205    type Error = T::Error;
206
207    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error>
208    where
209        Self: Sized,
210    {
211        let mut v = Vec::<T>::new();
212        if let Some(out) = <dyn Any>::downcast_mut::<Vec<u8>>(&mut v) {
213            let len = U56::decode(buf)?.0.try_into().unwrap();
214
215            out.extend_from_slice(buf.bytes_r.read(len)?);
216        } else {
217            let len = usize::try_from(u32::decode(buf)?).unwrap();
218
219            v.reserve_exact(len);
220            for _ in 0..len {
221                v.push(T::decode(buf)?);
222            }
223        }
224
225        Ok(v)
226    }
227}
228
229impl<const LEN: usize> Encodable for [u8; LEN] {
230    fn encode(&self, out: &mut Writer) {
231        out.bytes_w.write(self)
232    }
233}
234
235impl<const LEN: usize> Decodable for [u8; LEN] {
236    type Error = Error;
237
238    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
239        let mut v = [0; LEN];
240        v.copy_from_slice(buf.bytes_r.read(LEN).map_err(|_| Error::OverFlowError)?);
241        Ok(v)
242    }
243}
244
245impl<T, const LEN: usize> Encodable for arrayvec::ArrayVec<T, LEN>
246where
247    T: Encodable + 'static,
248{
249    fn encode(&self, out: &mut Writer) {
250        if let Some(s) = <dyn Any>::downcast_ref::<arrayvec::ArrayVec<u8, LEN>>(self) {
251            s.as_slice().encode(out)
252        } else {
253            u32::try_from(self.len()).unwrap().encode(out);
254            for item in self {
255                item.encode(out)
256            }
257        }
258    }
259}
260
261impl<T, const LEN: usize> Decodable for arrayvec::ArrayVec<T, LEN>
262where
263    T: Decodable + 'static,
264    T::Error: From<Error>,
265{
266    type Error = T::Error;
267
268    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error>
269    where
270        Self: Sized,
271    {
272        let mut v = Self::new();
273        if let Some(out) = <dyn Any>::downcast_mut::<arrayvec::ArrayVec<u8, LEN>>(&mut v) {
274            let len = U56::decode(buf)?.0.try_into().unwrap();
275
276            out.try_extend_from_slice(buf.bytes_r.read(len)?)
277                .map_err(|_| Error::OverFlowError)?;
278        } else {
279            let len = usize::try_from(u32::decode(buf)?).unwrap();
280
281            for _ in 0..len {
282                v.try_push(T::decode(buf)?)
283                    .map_err(|_| Error::OverFlowError)?;
284            }
285        }
286
287        Ok(v)
288    }
289}
290
291impl Encodable for String {
292    fn encode(&self, out: &mut Writer) {
293        self.as_bytes().encode(out)
294    }
295}
296
297impl Decodable for String {
298    type Error = anyhow::Error;
299
300    fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error> {
301        Ok(String::from_utf8(Decodable::decode(buf)?)?)
302    }
303}
304
305#[macro_export]
306macro_rules! impl_encodable_for_wrapper {
307    ($wrapper:ty, $base:ty) => {
308        impl $crate::Encodable for $wrapper {
309            fn encode(&self, out: &mut $crate::Writer) {
310                self.0.encode(out)
311            }
312        }
313
314        impl $crate::Decodable for $wrapper {
315            type Error = <$base as $crate::Decodable>::Error;
316
317            fn decode(buf: &mut $crate::Reader<'_>) -> Result<Self, Self::Error> {
318                <$base>::decode(buf).map(<$wrapper>::from)
319            }
320        }
321    };
322}
323
324#[cfg(feature = "ethereum-types")]
325mod ethereum_types_impl {
326    impl_encodable_for_wrapper!(ethereum_types::Address, [u8; 20]);
327    impl_encodable_for_wrapper!(ethereum_types::H256, [u8; 32]);
328    impl_encodable_for_wrapper!(ethereum_types::H512, [u8; 64]);
329}
330
331#[cfg(feature = "ethnum")]
332mod ethnum_impl {
333    use super::*;
334
335    impl Encodable for ethnum::U256 {
336        fn encode(&self, out: &mut Writer) {
337            let v = self.to_be_bytes();
338            let v = v.as_ref();
339            let v = &v[v.iter().take_while(|&&b| b == 0).count()..];
340
341            Encodable::encode(&v, out)
342        }
343    }
344
345    impl Decodable for ethnum::U256 {
346        type Error = Error;
347
348        fn decode(buf: &mut Reader<'_>) -> Result<Self, Self::Error>
349        where
350            Self: Sized,
351        {
352            let data = arrayvec::ArrayVec::<u8, { (Self::BITS / 8) as usize }>::decode(buf)?;
353
354            let mut v = [0; (Self::BITS / 8) as usize];
355
356            v[(Self::BITS / 8) as usize - data.len()..].copy_from_slice(&data);
357            Ok(Self::from_be_bytes(v))
358        }
359    }
360}
cser/imp.rs

cser/
imp.rs
