github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-04-28 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

serial: Use mutable references for non-async {en,de}code functions

Browse Source
This commit is contained in:
parazyd
2024-05-17 12:49:01 +02:00
parent c3433efe2e
commit f87382e856
11 changed files with 209 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/blockchain/block_store.rs
View File

@@ -190,25 +190,25 @@ impl BlockRanks {
// Note: Doing all the imports here as this might get obselete if
// we implemented Encodable/Decodable for num_bigint::BigUint.
impl darkfi_serial::Encodable for BlockRanks {
fn encode<S: std::io::Write>(&self, mut s: S) -> std::io::Result<usize> {
fn encode<S: std::io::Write>(&self, s: &mut S) -> std::io::Result<usize> {
let mut len = 0;
len += self.target_rank.to_bytes_be().encode(&mut s)?;
len += self.targets_rank.to_bytes_be().encode(&mut s)?;
len += self.hash_rank.to_bytes_be().encode(&mut s)?;
len += self.hashes_rank.to_bytes_be().encode(&mut s)?;
len += self.target_rank.to_bytes_be().encode(s)?;
len += self.targets_rank.to_bytes_be().encode(s)?;
len += self.hash_rank.to_bytes_be().encode(s)?;
len += self.hashes_rank.to_bytes_be().encode(s)?;
Ok(len)
}
}
impl darkfi_serial::Decodable for BlockRanks {
fn decode<D: std::io::Read>(mut d: D) -> std::io::Result<Self> {
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
fn decode<D: std::io::Read>(d: &mut D) -> std::io::Result<Self> {
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
let target_rank: BigUint = BigUint::from_bytes_be(&bytes);
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
let targets_rank: BigUint = BigUint::from_bytes_be(&bytes);
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
let hash_rank: BigUint = BigUint::from_bytes_be(&bytes);
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
let hashes_rank: BigUint = BigUint::from_bytes_be(&bytes);
let ret = Self { target_rank, targets_rank, hash_rank, hashes_rank };
Ok(ret)
@@ -259,26 +259,26 @@ impl BlockDifficulty {
// Note: Doing all the imports here as this might get obselete if
// we implemented Encodable/Decodable for num_bigint::BigUint.
impl darkfi_serial::Encodable for BlockDifficulty {
fn encode<S: std::io::Write>(&self, mut s: S) -> std::io::Result<usize> {
fn encode<S: std::io::Write>(&self, s: &mut S) -> std::io::Result<usize> {
let mut len = 0;
len += self.height.encode(&mut s)?;
len += self.timestamp.encode(&mut s)?;
len += self.difficulty.to_bytes_be().encode(&mut s)?;
len += self.cummulative_difficulty.to_bytes_be().encode(&mut s)?;
len += self.ranks.encode(&mut s)?;
len += self.height.encode(s)?;
len += self.timestamp.encode(s)?;
len += self.difficulty.to_bytes_be().encode(s)?;
len += self.cummulative_difficulty.to_bytes_be().encode(s)?;
len += self.ranks.encode(s)?;
Ok(len)
}
}
impl darkfi_serial::Decodable for BlockDifficulty {
fn decode<D: std::io::Read>(mut d: D) -> std::io::Result<Self> {
let height: u32 = darkfi_serial::Decodable::decode(&mut d)?;
let timestamp: Timestamp = darkfi_serial::Decodable::decode(&mut d)?;
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
fn decode<D: std::io::Read>(d: &mut D) -> std::io::Result<Self> {
let height: u32 = darkfi_serial::Decodable::decode(d)?;
let timestamp: Timestamp = darkfi_serial::Decodable::decode(d)?;
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
let difficulty: BigUint = BigUint::from_bytes_be(&bytes);
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(&mut d)?;
let bytes: Vec<u8> = darkfi_serial::Decodable::decode(d)?;
let cummulative_difficulty: BigUint = BigUint::from_bytes_be(&bytes);
let ranks: BlockRanks = darkfi_serial::Decodable::decode(&mut d)?;
let ranks: BlockRanks = darkfi_serial::Decodable::decode(d)?;
let ret = Self { height, timestamp, difficulty, cummulative_difficulty, ranks };
Ok(ret)
}

7
src/sdk/src/crypto/note.rs
View File

@@ -16,6 +16,8 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use std::io::Cursor;
use chacha20poly1305::{AeadInPlace, ChaCha20Poly1305, KeyInit};
use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
use pasta_curves::{group::ff::Field, pallas};
@@ -75,7 +77,10 @@ impl AeadEncryptedNote {
&[],
&mut plaintext,
) {
Ok(()) => Ok(D::decode(&plaintext[..ct_len - AEAD_TAG_SIZE])?),
Ok(()) => {
let mut cursor = Cursor::new(&plaintext[..ct_len - AEAD_TAG_SIZE]);
Ok(D::decode(&mut cursor)?)
}
Err(e) => Err(ContractError::IoError(format!("Note decrypt failed: {}", e))),
}
}

2
src/sdk/src/wasm/util.rs
View File

@@ -178,7 +178,7 @@ pub fn get_tx_location(hash: &TransactionHash) -> GenericResult<(u32, u16)> {
let ret = unsafe { get_tx_location_(buf.as_ptr()) };
let loc_data = parse_ret(ret)?.ok_or(ContractError::DbGetFailed)?;
let mut cursor = Cursor::new(loc_data);
Ok((Decodable::decode(&mut cursor)?, Decodable::decode(cursor)?))
Ok((Decodable::decode(&mut cursor)?, Decodable::decode(&mut cursor)?))
}
extern "C" {

28
src/serial/derive-internal/src/sync_derive.rs
View File

@@ -51,7 +51,7 @@ fn named_fields(
);
variant_body.extend(quote! {
len += #field_ident.encode(&mut s)?;
len += #field_ident.encode(s)?;
})
}
}
@@ -94,7 +94,7 @@ fn unnamed_fields(
);
variant_body.extend(quote! {
len += #field_ident.encode(&mut s)?;
len += #field_ident.encode(s)?;
})
}
}
@@ -156,7 +156,7 @@ pub fn enum_ser(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream>
Ok(quote! {
impl #impl_generics #cratename::Encodable for #enum_ident #ty_generics #where_clause {
fn encode<S: std::io::Write>(&self, mut s: S) -> ::core::result::Result<usize, std::io::Error> {
fn encode<S: std::io::Write>(&self, s: &mut S) -> ::core::result::Result<usize, std::io::Error> {
let variant_idx: u8 = match self {
#all_variants_idx_body
};
@@ -210,7 +210,7 @@ pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream> {
);
variant_header.extend(quote! {
#field_name: #cratename::Decodable::decode(&mut d)?,
#field_name: #cratename::Decodable::decode(d)?,
});
}
}
@@ -230,7 +230,7 @@ pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream> {
);
variant_header.extend(quote! {
#cratename::Decodable::decode(&mut d)?,
#cratename::Decodable::decode(d)?,
});
}
}
@@ -253,8 +253,8 @@ pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream> {
Ok(quote! {
impl #impl_generics #cratename::Decodable for #name #ty_generics #where_clause {
fn decode<D: std::io::Read>(mut d: D) -> ::core::result::Result<Self, std::io::Error> {
let variant_tag: u8 = #cratename::Decodable::decode(&mut d)?;
fn decode<D: std::io::Read>(d: &mut D) -> ::core::result::Result<Self, std::io::Error> {
let variant_tag: u8 = #cratename::Decodable::decode(d)?;
let mut return_value =
#variant_arms {
@@ -289,7 +289,7 @@ pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStre
let field_name = field.ident.as_ref().unwrap();
let delta = quote! {
len += self.#field_name.encode(&mut s)?;
len += self.#field_name.encode(s)?;
};
body.extend(delta);
@@ -309,7 +309,7 @@ pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStre
span: Span::call_site(),
};
let delta = quote! {
len += self.#field_idx.encode(&mut s)?;
len += self.#field_idx.encode(s)?;
};
body.extend(delta);
}
@@ -319,7 +319,7 @@ pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStre
Ok(quote! {
impl #impl_generics #cratename::Encodable for #name #ty_generics #where_clause {
fn encode<S: std::io::Write>(&self, mut s: S) -> ::core::result::Result<usize, std::io::Error> {
fn encode<S: std::io::Write>(&self, s: &mut S) -> ::core::result::Result<usize, std::io::Error> {
let mut len = 0;
#body
Ok(len)
@@ -357,7 +357,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
);
quote! {
#field_name: #cratename::Decodable::decode(&mut d)?,
#field_name: #cratename::Decodable::decode(d)?,
}
};
body.extend(delta);
@@ -370,7 +370,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
let mut body = TokenStream::new();
for _ in 0..fields.unnamed.len() {
let delta = quote! {
#cratename::Decodable::decode(&mut d)?,
#cratename::Decodable::decode(d)?,
};
body.extend(delta);
}
@@ -388,7 +388,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
if let Some(method_ident) = init_method {
Ok(quote! {
impl #impl_generics #cratename::Decodable for #name #ty_generics #where_clause {
fn decode<D: std::io::Read>(mut d: D) -> ::core::result::Result<Self, std::io::Error> {
fn decode<D: std::io::Read>(d: &mut D) -> ::core::result::Result<Self, std::io::Error> {
let mut return_value = #return_value;
return_value.#method_ident();
Ok(return_value)
@@ -398,7 +398,7 @@ pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStrea
} else {
Ok(quote! {
impl #impl_generics #cratename::Decodable for #name #ty_generics #where_clause {
fn decode<D: std::io::Read>(mut d: D) -> ::core::result::Result<Self, std::io::Error> {
fn decode<D: std::io::Read>(d: &mut D) -> ::core::result::Result<Self, std::io::Error> {
Ok(#return_value)
}
}

110
src/serial/src/lib.rs
View File

@@ -41,12 +41,12 @@ pub trait Encodable {
/// Encode an object with a well-defined format.
/// Should only ever error if the underlying `Write` errors.
/// Returns the number of bytes written on success.
fn encode<W: Write>(&self, e: W) -> Result<usize, Error>;
fn encode<W: Write>(&self, e: &mut W) -> Result<usize, Error>;
}
/// Data which can be decoded in a consensus-consistent way.
pub trait Decodable: Sized {
fn decode<D: Read>(d: D) -> Result<Self, Error>;
fn decode<D: Read>(d: &mut D) -> Result<Self, Error>;
}
/// Encode an object into a vector.
@@ -241,14 +241,14 @@ macro_rules! impl_int_encodable {
($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
impl Decodable for $ty {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
ReadExt::$meth_dec(&mut d).map($ty::from_le)
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
ReadExt::$meth_dec(d).map($ty::from_le)
}
}
impl Encodable for $ty {
#[inline]
fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
s.$meth_enc(self.to_le())?;
Ok(core::mem::size_of::<$ty>())
}
@@ -304,7 +304,7 @@ impl VarInt {
impl Encodable for VarInt {
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
match self.0 {
0..=0xFC => {
(self.0 as u8).encode(s)?;
@@ -334,11 +334,11 @@ impl Encodable for VarInt {
impl Decodable for VarInt {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let n = ReadExt::read_u8(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
let n = ReadExt::read_u8(d)?;
match n {
0xFF => {
let x = ReadExt::read_u64(&mut d)?;
let x = ReadExt::read_u64(d)?;
if x < 0x100000000 {
return Err(Error::new(ErrorKind::Other, "Non-minimal VarInt"))
}
@@ -346,7 +346,7 @@ impl Decodable for VarInt {
}
0xFE => {
let x = ReadExt::read_u32(&mut d)?;
let x = ReadExt::read_u32(d)?;
if x < 0x10000 {
return Err(Error::new(ErrorKind::Other, "Non-minimal VarInt"))
}
@@ -354,7 +354,7 @@ impl Decodable for VarInt {
}
0xFD => {
let x = ReadExt::read_u16(&mut d)?;
let x = ReadExt::read_u16(d)?;
if x < 0xFD {
return Err(Error::new(ErrorKind::Other, "Non-minimal VarInt"))
}
@@ -371,10 +371,10 @@ macro_rules! tuple_encode {
impl<$($x: Encodable),*> Encodable for ($($x),*) {
#[inline]
#[allow(non_snake_case)]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let &($(ref $x),*) = self;
let mut len = 0;
$(len += $x.encode(&mut s)?;)*
$(len += $x.encode(s)?;)*
Ok(len)
}
}
@@ -382,8 +382,8 @@ macro_rules! tuple_encode {
impl<$($x: Decodable),*> Decodable for ($($x),*) {
#[inline]
#[allow(non_snake_case)]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
Ok(($({let $x = Decodable::decode(&mut d)?; $x }),*))
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
Ok(($({let $x = Decodable::decode(d)?; $x }),*))
}
}
)
@@ -406,7 +406,7 @@ macro_rules! encode_payload {
// Implementations for some primitive types.
impl Encodable for usize {
#[inline]
fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
s.write_u64(*self as u64)?;
Ok(8)
}
@@ -414,14 +414,14 @@ impl Encodable for usize {
impl Decodable for usize {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
Ok(ReadExt::read_u64(&mut d)? as usize)
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
Ok(ReadExt::read_u64(d)? as usize)
}
}
impl Encodable for f64 {
#[inline]
fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
s.write_f64(*self)?;
Ok(core::mem::size_of::<f64>())
}
@@ -429,14 +429,14 @@ impl Encodable for f64 {
impl Decodable for f64 {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
ReadExt::read_f64(&mut d)
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
ReadExt::read_f64(d)
}
}
impl Encodable for f32 {
#[inline]
fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
s.write_f32(*self)?;
Ok(core::mem::size_of::<f32>())
}
@@ -444,14 +444,14 @@ impl Encodable for f32 {
impl Decodable for f32 {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
ReadExt::read_f32(&mut d)
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
ReadExt::read_f32(d)
}
}
impl Encodable for bool {
#[inline]
fn encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
s.write_bool(*self)?;
Ok(1)
}
@@ -459,18 +459,18 @@ impl Encodable for bool {
impl Decodable for bool {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
ReadExt::read_bool(&mut d)
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
ReadExt::read_bool(d)
}
}
impl<T: Encodable> Encodable for Vec<T> {
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
len += VarInt(self.len() as u64).encode(s)?;
for val in self {
len += val.encode(&mut s)?;
len += val.encode(s)?;
}
Ok(len)
}
@@ -478,12 +478,12 @@ impl<T: Encodable> Encodable for Vec<T> {
impl<T: Decodable> Decodable for Vec<T> {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let len = VarInt::decode(&mut d)?.0;
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
let len = VarInt::decode(d)?.0;
let mut ret = Vec::new();
ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
for _ in 0..len {
ret.push(Decodable::decode(&mut d)?);
ret.push(Decodable::decode(d)?);
}
Ok(ret)
}
@@ -491,11 +491,11 @@ impl<T: Decodable> Decodable for Vec<T> {
impl<T: Encodable> Encodable for VecDeque<T> {
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
len += VarInt(self.len() as u64).encode(s)?;
for val in self {
len += val.encode(&mut s)?;
len += val.encode(s)?;
}
Ok(len)
}
@@ -503,34 +503,34 @@ impl<T: Encodable> Encodable for VecDeque<T> {
impl<T: Decodable> Decodable for VecDeque<T> {
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let len = VarInt::decode(&mut d)?.0;
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
let len = VarInt::decode(d)?.0;
let mut ret = VecDeque::new();
ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
for _ in 0..len {
ret.push_back(Decodable::decode(&mut d)?);
ret.push_back(Decodable::decode(d)?);
}
Ok(ret)
}
}
impl<T: Encodable> Encodable for Option<T> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let mut len = 0;
if let Some(v) = self {
len += true.encode(&mut s)?;
len += v.encode(&mut s)?;
len += true.encode(s)?;
len += v.encode(s)?;
} else {
len += false.encode(&mut s)?;
len += false.encode(s)?;
}
Ok(len)
}
}
impl<T: Decodable> Decodable for Option<T> {
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
let valid: bool = Decodable::decode(&mut d)?;
let val = if valid { Some(Decodable::decode(&mut d)?) } else { None };
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
let valid: bool = Decodable::decode(d)?;
let val = if valid { Some(Decodable::decode(d)?) } else { None };
Ok(val)
}
}
@@ -540,10 +540,10 @@ where
T: Encodable,
{
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let mut len = 0;
for elem in self.iter() {
len += elem.encode(&mut s)?;
len += elem.encode(s)?;
}
Ok(len)
}
@@ -554,10 +554,10 @@ where
T: Decodable + core::fmt::Debug,
{
#[inline]
fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
let mut ret = vec![];
for _ in 0..N {
ret.push(Decodable::decode(&mut d)?);
ret.push(Decodable::decode(d)?);
}
Ok(ret.try_into().unwrap())
@@ -566,10 +566,10 @@ where
impl Encodable for String {
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let b = self.as_bytes();
let b_len = b.len();
let vi_len = VarInt(b_len as u64).encode(&mut s)?;
let vi_len = VarInt(b_len as u64).encode(s)?;
s.write_slice(b)?;
Ok(vi_len + b_len)
}
@@ -577,10 +577,10 @@ impl Encodable for String {
impl Encodable for &str {
#[inline]
fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
let b = self.as_bytes();
let b_len = b.len();
let vi_len = VarInt(b_len as u64).encode(&mut s)?;
let vi_len = VarInt(b_len as u64).encode(s)?;
s.write_slice(b)?;
Ok(vi_len + b_len)
}
@@ -588,7 +588,7 @@ impl Encodable for &str {
impl Decodable for String {
#[inline]
fn decode<D: Read>(d: D) -> Result<String, Error> {
fn decode<D: Read>(d: &mut D) -> Result<String, Error> {
match String::from_utf8(Decodable::decode(d)?) {
Ok(v) => Ok(v),
Err(_) => Err(Error::new(ErrorKind::Other, "Invalid UTF-8 for string")),

100
src/serial/src/types/bridgetree.rs
View File

@@ -29,8 +29,8 @@ use futures_lite::{AsyncRead, AsyncWrite};
use crate::{Decodable, Encodable};
impl Encodable for bridgetree::Position {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
u64::from(*self).encode(&mut s)
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
u64::from(*self).encode(s)
}
}
@@ -43,8 +43,8 @@ impl AsyncEncodable for bridgetree::Position {
}
impl Decodable for bridgetree::Position {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let dec: u64 = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let dec: u64 = Decodable::decode(d)?;
Ok(Self::from(dec))
}
}
@@ -59,10 +59,10 @@ impl AsyncDecodable for bridgetree::Position {
}
impl Encodable for bridgetree::Address {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += u8::from(self.level()).encode(&mut s)?;
len += self.index().encode(&mut s)?;
len += u8::from(self.level()).encode(s)?;
len += self.index().encode(s)?;
Ok(len)
}
}
@@ -79,9 +79,9 @@ impl AsyncEncodable for bridgetree::Address {
}
impl Decodable for bridgetree::Address {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let level: u8 = Decodable::decode(&mut d)?;
let index = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let level: u8 = Decodable::decode(d)?;
let index = Decodable::decode(d)?;
Ok(Self::from_parts(level.into(), index))
}
}
@@ -97,11 +97,11 @@ impl AsyncDecodable for bridgetree::Address {
}
impl<H: Encodable + Ord + Clone> Encodable for bridgetree::NonEmptyFrontier<H> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += self.position().encode(&mut s)?;
len += self.leaf().encode(&mut s)?;
len += self.ommers().to_vec().encode(&mut s)?;
len += self.position().encode(s)?;
len += self.leaf().encode(s)?;
len += self.ommers().to_vec().encode(s)?;
Ok(len)
}
}
@@ -121,10 +121,10 @@ impl<H: AsyncEncodable + Sync + Send + Ord + Clone> AsyncEncodable
}
impl<H: Decodable + Ord + Clone> Decodable for bridgetree::NonEmptyFrontier<H> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let position = Decodable::decode(&mut d)?;
let leaf = Decodable::decode(&mut d)?;
let ommers = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let position = Decodable::decode(d)?;
let leaf = Decodable::decode(d)?;
let ommers = Decodable::decode(d)?;
match Self::from_parts(position, leaf, ommers) {
Ok(v) => Ok(v),
@@ -149,12 +149,12 @@ impl<H: AsyncDecodable + Send + Ord + Clone> AsyncDecodable for bridgetree::NonE
}
impl<H: Encodable + Ord + Clone> Encodable for bridgetree::MerkleBridge<H> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += self.prior_position().encode(&mut s)?;
len += self.tracking().encode(&mut s)?;
len += self.ommers().encode(&mut s)?;
len += self.frontier().encode(&mut s)?;
len += self.prior_position().encode(s)?;
len += self.tracking().encode(s)?;
len += self.ommers().encode(s)?;
len += self.frontier().encode(s)?;
Ok(len)
}
}
@@ -173,11 +173,11 @@ impl<H: AsyncEncodable + Sync + Send + Ord + Clone> AsyncEncodable for bridgetre
}
impl<H: Decodable + Ord + Clone> Decodable for bridgetree::MerkleBridge<H> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let prior_position = Decodable::decode(&mut d)?;
let tracking = Decodable::decode(&mut d)?;
let ommers = Decodable::decode(&mut d)?;
let frontier = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let prior_position = Decodable::decode(d)?;
let tracking = Decodable::decode(d)?;
let ommers = Decodable::decode(d)?;
let frontier = Decodable::decode(d)?;
Ok(Self::from_parts(prior_position, tracking, ommers, frontier))
}
}
@@ -195,12 +195,12 @@ impl<H: AsyncDecodable + Send + Ord + Clone> AsyncDecodable for bridgetree::Merk
}
impl<C: Encodable> Encodable for bridgetree::Checkpoint<C> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += self.id().encode(&mut s)?;
len += self.bridges_len().encode(&mut s)?;
len += self.marked().encode(&mut s)?;
len += self.forgotten().encode(&mut s)?;
len += self.id().encode(s)?;
len += self.bridges_len().encode(s)?;
len += self.marked().encode(s)?;
len += self.forgotten().encode(s)?;
Ok(len)
}
}
@@ -219,11 +219,11 @@ impl<C: AsyncEncodable + Sync> AsyncEncodable for bridgetree::Checkpoint<C> {
}
impl<C: Decodable> Decodable for bridgetree::Checkpoint<C> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let id = Decodable::decode(&mut d)?;
let bridges_len = Decodable::decode(&mut d)?;
let marked = Decodable::decode(&mut d)?;
let forgotten = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let id = Decodable::decode(d)?;
let bridges_len = Decodable::decode(d)?;
let marked = Decodable::decode(d)?;
let forgotten = Decodable::decode(d)?;
Ok(Self::from_parts(id, bridges_len, marked, forgotten))
}
}
@@ -243,13 +243,13 @@ impl<C: AsyncDecodable + Send> AsyncDecodable for bridgetree::Checkpoint<C> {
impl<H: Encodable + Ord + Clone, C: Encodable + Debug, const DEPTH: u8> Encodable
for bridgetree::BridgeTree<H, C, DEPTH>
{
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += self.prior_bridges().to_vec().encode(&mut s)?;
len += self.current_bridge().encode(&mut s)?;
len += self.marked_indices().encode(&mut s)?;
len += self.checkpoints().encode(&mut s)?;
len += self.max_checkpoints().encode(&mut s)?;
len += self.prior_bridges().to_vec().encode(s)?;
len += self.current_bridge().encode(s)?;
len += self.marked_indices().encode(s)?;
len += self.checkpoints().encode(s)?;
len += self.max_checkpoints().encode(s)?;
Ok(len)
}
}
@@ -279,12 +279,12 @@ impl<
const DEPTH: u8,
> Decodable for bridgetree::BridgeTree<H, C, DEPTH>
{
fn decode<D: Read>(mut d: D) -> Result<Self> {
let prior_bridges = Decodable::decode(&mut d)?;
let current_bridge = Decodable::decode(&mut d)?;
let saved = Decodable::decode(&mut d)?;
let checkpoints = Decodable::decode(&mut d)?;
let max_checkpoints = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let prior_bridges = Decodable::decode(d)?;
let current_bridge = Decodable::decode(d)?;
let saved = Decodable::decode(d)?;
let checkpoints = Decodable::decode(d)?;
let max_checkpoints = Decodable::decode(d)?;
match Self::from_parts(prior_bridges, current_bridge, saved, checkpoints, max_checkpoints) {
Ok(v) => Ok(v),
Err(_) => Err(Error::new(ErrorKind::Other, "BridgeTreeError")),

56
src/serial/src/types/collections.rs
View File

@@ -32,11 +32,11 @@ use futures_lite::{AsyncRead, AsyncWrite};
use crate::{Decodable, Encodable, VarInt};
impl<T: Encodable> Encodable for HashSet<T> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
len += VarInt(self.len() as u64).encode(s)?;
for c in self.iter() {
len += c.encode(&mut s)?;
len += c.encode(s)?;
}
Ok(len)
}
@@ -56,11 +56,11 @@ impl<T: AsyncEncodable + Sync> AsyncEncodable for HashSet<T> {
}
impl<T: Decodable + std::cmp::Eq + std::hash::Hash> Decodable for HashSet<T> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let len = VarInt::decode(&mut d)?.0;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let len = VarInt::decode(d)?.0;
let mut ret = HashSet::new();
for _ in 0..len {
let entry: T = Decodable::decode(&mut d)?;
let entry: T = Decodable::decode(d)?;
ret.insert(entry);
}
Ok(ret)
@@ -82,12 +82,12 @@ impl<T: AsyncDecodable + Send + std::cmp::Eq + std::hash::Hash> AsyncDecodable f
}
impl<T: Encodable, U: Encodable> Encodable for BTreeMap<T, U> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
len += VarInt(self.len() as u64).encode(s)?;
for c in self.iter() {
len += c.0.encode(&mut s)?;
len += c.1.encode(&mut s)?;
len += c.0.encode(s)?;
len += c.1.encode(s)?;
}
Ok(len)
}
@@ -108,12 +108,12 @@ impl<T: AsyncEncodable + Sync, U: AsyncEncodable + Sync> AsyncEncodable for BTre
}
impl<T: Decodable + std::cmp::Ord, U: Decodable> Decodable for BTreeMap<T, U> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let len = VarInt::decode(&mut d)?.0;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let len = VarInt::decode(d)?.0;
let mut ret = BTreeMap::new();
for _ in 0..len {
let key: T = Decodable::decode(&mut d)?;
let entry: U = Decodable::decode(&mut d)?;
let key: T = Decodable::decode(d)?;
let entry: U = Decodable::decode(d)?;
ret.insert(key, entry);
}
Ok(ret)
@@ -138,11 +138,11 @@ impl<T: AsyncDecodable + Send + std::cmp::Ord, U: AsyncDecodable + Send> AsyncDe
}
impl<T: Encodable> Encodable for BTreeSet<T> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
len += VarInt(self.len() as u64).encode(s)?;
for c in self.iter() {
len += c.encode(&mut s)?;
len += c.encode(s)?;
}
Ok(len)
}
@@ -162,11 +162,11 @@ impl<T: AsyncEncodable + Sync> AsyncEncodable for BTreeSet<T> {
}
impl<T: Decodable + std::cmp::Ord> Decodable for BTreeSet<T> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let len = VarInt::decode(&mut d)?.0;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let len = VarInt::decode(d)?.0;
let mut ret = BTreeSet::new();
for _ in 0..len {
let key: T = Decodable::decode(&mut d)?;
let key: T = Decodable::decode(d)?;
ret.insert(key);
}
Ok(ret)
@@ -188,12 +188,12 @@ impl<T: AsyncDecodable + Send + std::cmp::Ord> AsyncDecodable for BTreeSet<T> {
}
impl<T: Encodable, U: Encodable> Encodable for HashMap<T, U> {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += VarInt(self.len() as u64).encode(&mut s)?;
len += VarInt(self.len() as u64).encode(s)?;
for c in self.iter() {
len += c.0.encode(&mut s)?;
len += c.1.encode(&mut s)?;
len += c.0.encode(s)?;
len += c.1.encode(s)?;
}
Ok(len)
}
@@ -214,12 +214,12 @@ impl<T: AsyncEncodable + Sync, U: AsyncEncodable + Sync> AsyncEncodable for Hash
}
impl<T: Decodable + std::cmp::Eq + std::hash::Hash, U: Decodable> Decodable for HashMap<T, U> {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let len = VarInt::decode(&mut d)?.0;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let len = VarInt::decode(d)?.0;
let mut ret = HashMap::new();
for _ in 0..len {
let key: T = Decodable::decode(&mut d)?;
let entry: U = Decodable::decode(&mut d)?;
let key: T = Decodable::decode(d)?;
let entry: U = Decodable::decode(d)?;
ret.insert(key, entry);
}
Ok(ret)

4
src/serial/src/types/hash.rs
View File

@@ -28,7 +28,7 @@ use crate::{Decodable, Encodable, ReadExt, WriteExt};
#[cfg(feature = "blake3")]
impl Encodable for blake3::Hash {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
s.write_slice(self.as_bytes())?;
Ok(blake3::OUT_LEN)
}
@@ -45,7 +45,7 @@ impl AsyncEncodable for blake3::Hash {
#[cfg(feature = "blake3")]
impl Decodable for blake3::Hash {
fn decode<D: Read>(mut d: D) -> Result<Self> {
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let mut bytes = [0u8; blake3::OUT_LEN];
d.read_slice(&mut bytes)?;
Ok(bytes.into())

16
src/serial/src/types/pasta.rs
View File

@@ -37,7 +37,7 @@ use pasta_curves::{
use crate::{Decodable, Encodable, ReadExt, WriteExt};
impl Encodable for Fp {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
s.write_slice(&self.to_repr())?;
Ok(32)
}
@@ -53,7 +53,7 @@ impl AsyncEncodable for Fp {
}
impl Decodable for Fp {
fn decode<D: Read>(mut d: D) -> Result<Self> {
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let mut bytes = [0u8; 32];
d.read_slice(&mut bytes)?;
match Self::from_repr(bytes).into() {
@@ -76,7 +76,7 @@ impl AsyncDecodable for Fp {
}
impl Encodable for Fq {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
s.write_slice(&self.to_repr())?;
Ok(32)
}
@@ -92,7 +92,7 @@ impl AsyncEncodable for Fq {
}
impl Decodable for Fq {
fn decode<D: Read>(mut d: D) -> Result<Self> {
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let mut bytes = [0u8; 32];
d.read_slice(&mut bytes)?;
match Self::from_repr(bytes).into() {
@@ -116,7 +116,7 @@ impl AsyncDecodable for Fq {
}
impl Encodable for Ep {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
s.write_slice(&self.to_bytes())?;
Ok(32)
}
@@ -132,7 +132,7 @@ impl AsyncEncodable for Ep {
}
impl Decodable for Ep {
fn decode<D: Read>(mut d: D) -> Result<Self> {
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let mut bytes = [0u8; 32];
d.read_slice(&mut bytes)?;
match Self::from_bytes(&bytes).into() {
@@ -156,7 +156,7 @@ impl AsyncDecodable for Ep {
}
impl Encodable for Eq {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
s.write_slice(&self.to_bytes())?;
Ok(32)
}
@@ -172,7 +172,7 @@ impl AsyncEncodable for Eq {
}
impl Decodable for Eq {
fn decode<D: Read>(mut d: D) -> Result<Self> {
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let mut bytes = [0u8; 32];
d.read_slice(&mut bytes)?;
match Self::from_bytes(&bytes).into() {

40
src/serial/src/types/semver.rs
View File

@@ -28,8 +28,8 @@ use futures_lite::{AsyncRead, AsyncWrite};
use crate::{Decodable, Encodable};
impl Encodable for semver::Prerelease {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
self.as_str().encode(&mut s)
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
self.as_str().encode(s)
}
}
@@ -42,8 +42,8 @@ impl AsyncEncodable for semver::Prerelease {
}
impl Decodable for semver::Prerelease {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let s: String = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let s: String = Decodable::decode(d)?;
match Self::new(&s) {
Ok(v) => Ok(v),
@@ -66,8 +66,8 @@ impl AsyncDecodable for semver::Prerelease {
}
impl Encodable for semver::BuildMetadata {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
self.as_str().encode(&mut s)
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
self.as_str().encode(s)
}
}
@@ -80,8 +80,8 @@ impl AsyncEncodable for semver::BuildMetadata {
}
impl Decodable for semver::BuildMetadata {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let s: String = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let s: String = Decodable::decode(d)?;
match Self::new(&s) {
Ok(v) => Ok(v),
@@ -108,13 +108,13 @@ impl AsyncDecodable for semver::BuildMetadata {
}
impl Encodable for semver::Version {
fn encode<S: Write>(&self, mut s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
let mut len = 0;
len += self.major.encode(&mut s)?;
len += self.minor.encode(&mut s)?;
len += self.patch.encode(&mut s)?;
len += self.pre.encode(&mut s)?;
len += self.build.encode(&mut s)?;
len += self.major.encode(s)?;
len += self.minor.encode(s)?;
len += self.patch.encode(s)?;
len += self.pre.encode(s)?;
len += self.build.encode(s)?;
Ok(len)
}
}
@@ -134,12 +134,12 @@ impl AsyncEncodable for semver::Version {
}
impl Decodable for semver::Version {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let major: u64 = Decodable::decode(&mut d)?;
let minor: u64 = Decodable::decode(&mut d)?;
let patch: u64 = Decodable::decode(&mut d)?;
let pre: semver::Prerelease = Decodable::decode(&mut d)?;
let build: semver::BuildMetadata = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let major: u64 = Decodable::decode(d)?;
let minor: u64 = Decodable::decode(d)?;
let patch: u64 = Decodable::decode(d)?;
let pre: semver::Prerelease = Decodable::decode(d)?;
let build: semver::BuildMetadata = Decodable::decode(d)?;
Ok(Self { major, minor, patch, pre, build })
}
}

6
src/serial/src/types/url.rs
View File

@@ -29,7 +29,7 @@ use futures_lite::{AsyncRead, AsyncWrite};
use crate::{Decodable, Encodable};
impl Encodable for Url {
fn encode<S: Write>(&self, s: S) -> Result<usize> {
fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
self.as_str().encode(s)
}
}
@@ -43,8 +43,8 @@ impl AsyncEncodable for Url {
}
impl Decodable for Url {
fn decode<D: Read>(mut d: D) -> Result<Self> {
let s: String = Decodable::decode(&mut d)?;
fn decode<D: Read>(d: &mut D) -> Result<Self> {
let s: String = Decodable::decode(d)?;
match Url::parse(&s) {
Ok(v) => Ok(v),
Err(e) => Err(Error::new(ErrorKind::Other, e)),