neo3 1.1.1

Production-ready Rust SDK for Neo N3 blockchain with high-level API, unified error handling, and enterprise features
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
123
124
125

use std::fmt::Debug;

use crate::{
	codec::{CodecError, Decoder, Encoder},
	config::NeoConstants,
};
use primitive_types::{H160, H256};

pub trait NeoSerializable {
	type Error: Send + Sync + Debug;

	fn size(&self) -> usize;
	fn encode(&self, writer: &mut Encoder);
	fn decode(reader: &mut Decoder) -> Result<Self, Self::Error>
	where
		Self: Sized;
	fn to_array(&self) -> Vec<u8>;
}

impl NeoSerializable for H160 {
	type Error = CodecError;
	fn size(&self) -> usize {
		H160::len_bytes()
	}
	fn encode(&self, writer: &mut Encoder) {
		writer.write_bytes(self.as_fixed_bytes());
	}

	fn decode(reader: &mut Decoder) -> Result<Self, Self::Error>
	where
		Self: Sized,
	{
		let bytes = reader.read_bytes(NeoConstants::HASH160_SIZE as usize)?;
		<H160 as crate::neo_types::ScriptHashExtension>::from_slice(&bytes)
			.map_err(|_| CodecError::InvalidFormat)
	}

	fn to_array(&self) -> Vec<u8> {
		self.as_bytes().to_vec()
	}
}

impl NeoSerializable for H256 {
	type Error = CodecError;

	fn size(&self) -> usize {
		H256::len_bytes()
	}
	fn encode(&self, writer: &mut Encoder) {
		writer.write_bytes(self.as_bytes());
	}

	fn decode(reader: &mut Decoder) -> Result<Self, CodecError>
	where
		Self: Sized,
	{
		let bytes = reader.read_bytes(NeoConstants::HASH256_SIZE as usize)?;
		if bytes.len() != 32 {
			return Err(CodecError::InvalidFormat);
		}
		let mut arr = [0u8; 32];
		arr.copy_from_slice(&bytes);
		Ok(H256(arr))
	}

	fn to_array(&self) -> Vec<u8> {
		self.as_bytes().to_vec()
	}
}

impl NeoSerializable for u8 {
	type Error = CodecError;

	fn size(&self) -> usize {
		1
	}
	fn encode(&self, writer: &mut Encoder) {
		writer.write_u8(*self);
	}

	fn decode(reader: &mut Decoder) -> Result<Self, CodecError>
	where
		Self: Sized,
	{
		reader.read_u8_safe()
	}

	fn to_array(&self) -> Vec<u8> {
		vec![*self]
	}
}

pub trait VarSizeTrait {
	fn var_size(&self) -> usize;
	fn get_var_size(i: usize) -> usize {
		if i < 0xFD {
			1 // byte
		} else if i <= 0xFFFF {
			1 + 2 // 0xFD + uint16
		} else if i <= 0xFFFFFFFF {
			1 + 4 // 0xFE + uint32
		} else {
			1 + 8 // 0xFF + uint64
		}
	}
}

impl<T: NeoSerializable> VarSizeTrait for Vec<T> {
	fn var_size(&self) -> usize {
		let count_var_size = Self::get_var_size(self.len());
		count_var_size + self.iter().map(|item| item.size()).sum::<usize>()
	}
}

impl<T: NeoSerializable> VarSizeTrait for &[T] {
	fn var_size(&self) -> usize {
		let count_var_size = Self::get_var_size(self.len());
		count_var_size + self.iter().map(|item| item.size()).sum::<usize>()
	}
}

// fn var_size_of_serializables<T: NeoSerializable>(elements: &[T]) -> usize {
// 	let count_var_size = elements.len();
// 	count_var_size + elements.iter().map(|item| item.size()).sum::<usize>()
// }