muta_protocol/codec/
primitive.rs1use std::{convert::TryFrom, default::Default, mem};
2
3use byteorder::{ByteOrder, LittleEndian};
4use bytes::{Bytes, BytesMut};
5use derive_more::From;
6use prost::Message;
7
8use crate::{
9 codec::{CodecError, ProtocolCodecSync},
10 field, impl_default_bytes_codec_for,
11 types::primitive as protocol_primitive,
12 ProtocolError, ProtocolResult,
13};
14
15#[derive(Clone, Message)]
21pub struct Balance {
22 #[prost(bytes, tag = "1")]
23 pub value: Vec<u8>,
24}
25
26#[derive(Clone, Message, From)]
27pub struct Hash {
28 #[prost(bytes, tag = "1")]
29 pub value: Vec<u8>,
30}
31
32#[derive(Clone, Message, From)]
33pub struct MerkleRoot {
34 #[prost(message, tag = "1")]
35 pub value: Option<Hash>,
36}
37
38#[derive(Clone, Message, From)]
39pub struct Address {
40 #[prost(bytes, tag = "1")]
41 pub value: Vec<u8>,
42}
43
44impl From<protocol_primitive::Balance> for Balance {
51 fn from(balance: protocol_primitive::Balance) -> Balance {
52 let value = balance.to_bytes_be();
53 Balance { value }
54 }
55}
56
57impl TryFrom<Balance> for protocol_primitive::Balance {
58 type Error = ProtocolError;
59
60 fn try_from(ser_balance: Balance) -> Result<protocol_primitive::Balance, Self::Error> {
61 Ok(protocol_primitive::Balance::from_bytes_be(
62 &ser_balance.value,
63 ))
64 }
65}
66
67impl From<protocol_primitive::Hash> for Hash {
70 fn from(hash: protocol_primitive::Hash) -> Hash {
71 let value = hash.as_bytes().to_vec();
72
73 Hash { value }
74 }
75}
76
77impl TryFrom<Hash> for protocol_primitive::Hash {
78 type Error = ProtocolError;
79
80 fn try_from(hash: Hash) -> Result<protocol_primitive::Hash, Self::Error> {
81 let bytes = Bytes::from(hash.value);
82
83 protocol_primitive::Hash::from_bytes(bytes)
84 }
85}
86
87impl From<protocol_primitive::Address> for Address {
89 fn from(address: protocol_primitive::Address) -> Address {
90 let value = address.as_bytes().to_vec();
91
92 Address { value }
93 }
94}
95
96impl TryFrom<Address> for protocol_primitive::Address {
97 type Error = ProtocolError;
98
99 fn try_from(address: Address) -> Result<protocol_primitive::Address, Self::Error> {
100 let bytes = Bytes::from(address.value);
101
102 protocol_primitive::Address::from_bytes(bytes)
103 }
104}
105
106impl From<protocol_primitive::MerkleRoot> for MerkleRoot {
109 fn from(root: protocol_primitive::MerkleRoot) -> MerkleRoot {
110 let value = Some(Hash::from(root));
111
112 MerkleRoot { value }
113 }
114}
115
116impl TryFrom<MerkleRoot> for protocol_primitive::MerkleRoot {
117 type Error = ProtocolError;
118
119 fn try_from(root: MerkleRoot) -> Result<protocol_primitive::MerkleRoot, Self::Error> {
120 let hash = field!(root.value, "MerkleRoot", "value")?;
121
122 protocol_primitive::Hash::try_from(hash)
123 }
124}
125
126impl_default_bytes_codec_for!(primitive, [Balance, Hash]);
132
133impl ProtocolCodecSync for u64 {
134 fn encode_sync(&self) -> ProtocolResult<Bytes> {
135 let mut buf = [0u8; mem::size_of::<u64>()];
136 LittleEndian::write_u64(&mut buf, *self);
137
138 Ok(BytesMut::from(buf.as_ref()).freeze())
139 }
140
141 fn decode_sync(bytes: Bytes) -> ProtocolResult<Self> {
142 Ok(LittleEndian::read_u64(bytes.as_ref()))
143 }
144}
145
146#[allow(dead_code)]
151fn ensure_len(real: usize, expect: usize) -> Result<(), CodecError> {
152 if real != expect {
153 return Err(CodecError::WrongBytesLength { expect, real });
154 }
155
156 Ok(())
157}