1use std::fmt::Debug;
2
3use crate::{
4 codec::{CodecError, Decoder, Encoder},
5 config::NeoConstants,
6};
7use primitive_types::{H160, H256};
8
9pub trait NeoSerializable {
10 type Error: Send + Sync + Debug;
11
12 fn size(&self) -> usize;
13 fn encode(&self, writer: &mut Encoder);
14 fn decode(reader: &mut Decoder) -> Result<Self, Self::Error>
15 where
16 Self: Sized;
17 fn to_array(&self) -> Vec<u8>;
18}
19
20impl NeoSerializable for H160 {
21 type Error = CodecError;
22 fn size(&self) -> usize {
23 H160::len_bytes()
24 }
25 fn encode(&self, writer: &mut Encoder) {
26 writer.write_bytes(self.as_fixed_bytes());
27 }
28
29 fn decode(reader: &mut Decoder) -> Result<Self, Self::Error>
30 where
31 Self: Sized,
32 {
33 let bytes = reader.read_bytes(NeoConstants::HASH160_SIZE as usize)?;
34 <H160 as crate::neo_types::ScriptHashExtension>::from_slice(&bytes)
35 .map_err(|_| CodecError::InvalidFormat)
36 }
37
38 fn to_array(&self) -> Vec<u8> {
39 self.as_bytes().to_vec()
40 }
41}
42
43impl NeoSerializable for H256 {
44 type Error = CodecError;
45
46 fn size(&self) -> usize {
47 H256::len_bytes()
48 }
49 fn encode(&self, writer: &mut Encoder) {
50 writer.write_bytes(&self.as_bytes());
51 }
52
53 fn decode(reader: &mut Decoder) -> Result<Self, CodecError>
54 where
55 Self: Sized,
56 {
57 let bytes = reader.read_bytes(NeoConstants::HASH256_SIZE as usize)?;
58 if bytes.len() != 32 {
59 return Err(CodecError::InvalidFormat);
60 }
61 let mut arr = [0u8; 32];
62 arr.copy_from_slice(&bytes);
63 Ok(H256(arr))
64 }
65
66 fn to_array(&self) -> Vec<u8> {
67 self.as_bytes().to_vec()
68 }
69}
70
71impl NeoSerializable for u8 {
72 type Error = CodecError;
73
74 fn size(&self) -> usize {
75 1
76 }
77 fn encode(&self, writer: &mut Encoder) {
78 writer.write_u8(*self);
79 }
80
81 fn decode(reader: &mut Decoder) -> Result<Self, CodecError>
82 where
83 Self: Sized,
84 {
85 Ok(reader.read_u8())
86 }
87
88 fn to_array(&self) -> Vec<u8> {
89 vec![*self]
90 }
91}
92
93pub trait VarSizeTrait {
94 fn var_size(&self) -> usize;
95 fn get_var_size(i: usize) -> usize {
96 if i < 0xFD {
97 1 } else if i <= 0xFFFF {
99 1 + 2 } else if i <= 0xFFFFFFFF {
101 1 + 4 } else {
103 1 + 8 }
105 }
106}
107
108impl<T: NeoSerializable> VarSizeTrait for Vec<T> {
109 fn var_size(&self) -> usize {
110 let count_var_size = Self::get_var_size(self.len());
111 count_var_size + self.iter().map(|item| item.size()).sum::<usize>()
112 }
113}
114
115impl<T: NeoSerializable> VarSizeTrait for &[T] {
116 fn var_size(&self) -> usize {
117 let count_var_size = Self::get_var_size(self.len());
118 count_var_size + self.iter().map(|item| item.size()).sum::<usize>()
119 }
120}
121
122