cerc-io/lighthouse
10
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Add decode_ssz function for general deserialization

Browse Source
This commit is contained in:
NatoliChris 2018-09-18 15:53:53 +10:00
parent cc1fc5c0cc
commit 92ebe5da0d
No known key found for this signature in database
GPG Key ID: D3EA7DBA19945306
3 changed files with 95 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ssz/src/decode.rs
View File

@ -10,7 +10,21 @@ pub enum DecodeError {
} }
pub trait Decodable: Sized { pub trait Decodable: Sized {
fn ssz_decode(bytes: &[u8]) -> Result<Self, DecodeError>; fn ssz_decode(bytes: &[u8], index: usize) -> Result<Self, DecodeError>;
}
/// Decode the given bytes for the given type
///
/// The single ssz encoded value will be decoded as the given type at the
/// given index.
pub fn decode_ssz<T>(ssz_bytes: &[u8], index: usize)
-> Result<T, DecodeError>
where T: Decodable
{
if index >= ssz_bytes.len() {
return Err(DecodeError::OutOfBounds)
}
T::ssz_decode(ssz_bytes, index)
} }
/// Decode the nth element of some ssz list. /// Decode the nth element of some ssz list.

116
ssz/src/impl_decode.rs
View File

@ -5,22 +5,23 @@ use super::{
macro_rules! impl_decodable_for_uint { macro_rules! impl_decodable_for_uint {
($type: ident, $bit_size: expr) => { ($type: ident, $bit_size: expr) => {
impl Decodable for $type { impl Decodable for $type {
fn ssz_decode(bytes: &[u8]) fn ssz_decode(bytes: &[u8], index: usize)
-> Result<Self, DecodeError> -> Result<Self, DecodeError>
{ {
assert!((0 < $bit_size) & assert!((0 < $bit_size) &
($bit_size <= 64) & ($bit_size <= 64) &
($bit_size % 8 == 0)); ($bit_size % 8 == 0));
let max_bytes = $bit_size / 8; let max_bytes = $bit_size / 8;
if bytes.len() <= max_bytes { if bytes.len() >= (index + max_bytes) {
let end_bytes = index + max_bytes;
let mut result: $type = 0; let mut result: $type = 0;
for i in 0..bytes.len() { for i in index..end_bytes {
let offset = (bytes.len() - i - 1) * 8; let offset = ((index + max_bytes) - i - 1) * 8;
result = ((bytes[i] as $type) << offset) | result; result = ((bytes[i] as $type) << offset) | result;
}; };
Ok(result) Ok(result)
} else { } else {
Err(DecodeError::TooLong) Err(DecodeError::TooShort)
} }
} }
} }
@ -37,78 +38,119 @@ impl_decodable_for_uint!(usize, 64);
mod tests { mod tests {
use super::super::{ use super::super::{
DecodeError, DecodeError,
decode_ssz_list_element, decode_ssz,
}; };
#[test] #[test]
fn test_ssz_decode_u16() { fn test_ssz_decode_u16() {
let ssz = vec![0, 0, 1, 0]; let ssz = vec![0, 0];
let result: u16 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u16 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 0); assert_eq!(result, 0);
let ssz = vec![0, 0, 1, 16]; let ssz = vec![0, 16];
let result: u16 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u16 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 16); assert_eq!(result, 16);
let ssz = vec![0, 0, 2, 1, 0]; let ssz = vec![1, 0];
let result: u16 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u16 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 256); assert_eq!(result, 256);
let ssz = vec![0, 0, 2, 255, 255]; let ssz = vec![255, 255];
let result: u16 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u16 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 65535); assert_eq!(result, 65535);
let ssz = vec![0, 0, 3, 0, 0, 1]; let ssz = vec![1];
let result: Result<u16, DecodeError> = let result: Result<u16, DecodeError> =
decode_ssz_list_element(&ssz, 0); decode_ssz(&ssz, 0);
assert_eq!(result, Err(DecodeError::TooLong)); assert_eq!(result, Err(DecodeError::TooShort));
} }
#[test] #[test]
fn test_ssz_decode_u32() { fn test_ssz_decode_u32() {
let ssz = vec![0, 0, 1, 0]; let ssz = vec![0, 0, 0, 0];
let result: u32 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u32 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 0); assert_eq!(result, 0);
let ssz = vec![0, 0, 4, 255, 255, 255, 255]; let ssz = vec![0, 0, 1, 0];
let result: u32 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u32 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 256);
let ssz = vec![255, 255, 255, 0, 0, 1, 0];
let result: u32 = decode_ssz(&ssz, 3).unwrap();
assert_eq!(result, 256);
let ssz = vec![0,200, 1, 0];
let result: u32 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 13107456);
let ssz = vec![255, 255, 255, 255];
let result: u32 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 4294967295); assert_eq!(result, 4294967295);
let ssz = vec![0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 1]; let ssz = vec![0, 0, 1];
let result: Result<u32, DecodeError> = let result: Result<u32, DecodeError> =
decode_ssz_list_element(&ssz, 0); decode_ssz(&ssz, 0);
assert_eq!(result, Err(DecodeError::TooLong)); assert_eq!(result, Err(DecodeError::TooShort));
} }
#[test] #[test]
fn test_ssz_decode_u64() { fn test_ssz_decode_u64() {
let ssz = vec![0, 0, 1, 0]; let ssz = vec![0, 0, 0, 0, 0, 0, 0, 0];
let result: u64 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u64 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 0); assert_eq!(result, 0);
let ssz = vec![0, 0, 8, 255, 255, 255, 255, 255, 255, 255, 255]; let ssz = vec![255, 255, 255, 255, 255, 255, 255, 255];
let result: u64 = decode_ssz_list_element(&ssz, 0).unwrap(); let result: u64 = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 18446744073709551615); assert_eq!(result, 18446744073709551615);
let ssz = vec![0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 1]; let ssz = vec![255, 255, 255, 0, 0, 0, 0, 0, 0, 0];
let result: u64 = decode_ssz(&ssz, 2).unwrap();
assert_eq!(result, 18374686479671623680);
let ssz = vec![0,0,0,0,0,0,0];
let result: Result<u64, DecodeError> = let result: Result<u64, DecodeError> =
decode_ssz_list_element(&ssz, 0); decode_ssz(&ssz, 0);
assert_eq!(result, Err(DecodeError::TooLong)); assert_eq!(result, Err(DecodeError::TooShort));
} }
#[test] #[test]
fn test_ssz_decode_usize() { fn test_ssz_decode_usize() {
let ssz = vec![0, 0, 1, 0]; let ssz = vec![0, 0, 0, 0, 0, 0, 0, 0];
let result: usize = decode_ssz_list_element(&ssz, 0).unwrap(); let result: usize = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 0); assert_eq!(result, 0);
let ssz = vec![0, 0, 8, 255, 255, 255, 255, 255, 255, 255, 255]; let ssz = vec![0, 0, 8, 255, 255, 255, 255, 255, 255, 255, 255];
let result: usize = decode_ssz_list_element(&ssz, 0).unwrap(); let result: usize = decode_ssz(&ssz, 3).unwrap();
assert_eq!(result, 18446744073709551615); assert_eq!(result, 18446744073709551615);
let ssz = vec![0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 1]; let ssz = vec![255, 255, 255, 255, 255, 255, 255, 255];
let result: usize = decode_ssz(&ssz, 0).unwrap();
assert_eq!(result, 18446744073709551615);
let ssz = vec![0, 0, 0, 0, 0, 0, 1];
let result: Result<usize, DecodeError> = let result: Result<usize, DecodeError> =
decode_ssz_list_element(&ssz, 0); decode_ssz(&ssz, 0);
assert_eq!(result, Err(DecodeError::TooLong)); assert_eq!(result, Err(DecodeError::TooShort));
}
#[test]
fn test_decode_ssz_bounds() {
let err: Result<u16, DecodeError> = decode_ssz(
&vec![1],
2
);
assert_eq!(err, Err(DecodeError::OutOfBounds));
let err: Result<u16, DecodeError> = decode_ssz(
&vec![0, 0, 0, 0],
3
);
assert_eq!(err, Err(DecodeError::TooShort));
let result: u16 = decode_ssz(
&vec![0,0,0,0,1],
3
).unwrap();
assert_eq!(result, 1);
} }
} }

2
ssz/src/lib.rs
View File

@ -18,7 +18,7 @@ mod impl_decode;
pub use decode::{ pub use decode::{
Decodable, Decodable,
DecodeError, DecodeError,
decode_ssz_list_element, decode_ssz,
}; };
pub use encode::{ pub use encode::{
Encodable, Encodable,