232 lines
8.6 KiB
Rust
232 lines
8.6 KiB
Rust
/*
|
|
* This is a WIP of implementing an alternative
|
|
* serialization strategy. It attempts to follow Vitalik's
|
|
* "simpleserialize" format here:
|
|
* https://github.com/ethereum/beacon_chain/blob/master/beacon_chain/utils/simpleserialize.py
|
|
*
|
|
* This implementation is not final and would almost certainly
|
|
* have issues.
|
|
*/
|
|
extern crate bytes;
|
|
extern crate ethereum_types;
|
|
|
|
mod cached_tree_hash;
|
|
pub mod decode;
|
|
pub mod encode;
|
|
mod signed_root;
|
|
pub mod tree_hash;
|
|
|
|
mod impl_decode;
|
|
mod impl_encode;
|
|
mod impl_tree_hash;
|
|
|
|
pub use crate::decode::{decode, decode_ssz_list, Decodable, DecodeError};
|
|
pub use crate::encode::{Encodable, SszStream};
|
|
pub use crate::signed_root::SignedRoot;
|
|
pub use crate::tree_hash::{merkle_hash, TreeHash};
|
|
|
|
pub use hashing::hash;
|
|
|
|
pub const LENGTH_BYTES: usize = 4;
|
|
pub const MAX_LIST_SIZE: usize = 1 << (4 * 8);
|
|
|
|
/// Convenience function to SSZ encode an object supporting ssz::Encode.
|
|
pub fn ssz_encode<T>(val: &T) -> Vec<u8>
|
|
where
|
|
T: Encodable,
|
|
{
|
|
let mut ssz_stream = SszStream::new();
|
|
ssz_stream.append(val);
|
|
ssz_stream.drain()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
extern crate hex;
|
|
extern crate yaml_rust;
|
|
|
|
use self::yaml_rust::yaml;
|
|
use super::*;
|
|
use std::{fs::File, io::prelude::*, path::PathBuf};
|
|
|
|
#[test]
|
|
pub fn test_vector_uint_bounds() {
|
|
let mut file = {
|
|
let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
|
file_path_buf.push("src/test_vectors/uint_bounds.yaml");
|
|
|
|
File::open(file_path_buf).unwrap()
|
|
};
|
|
let mut yaml_str = String::new();
|
|
file.read_to_string(&mut yaml_str).unwrap();
|
|
let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
|
|
let doc = &docs[0];
|
|
|
|
// Load test cases
|
|
let test_cases = doc["test_cases"].clone();
|
|
|
|
for test_case in test_cases {
|
|
// Only the valid cases are checked as parse::<uX>() will fail for all invalid cases
|
|
if test_case["valid"].as_bool().unwrap() {
|
|
// Convert test vector 'ssz' encoded yaml to Vec<u8>
|
|
let ssz = test_case["ssz"].as_str().unwrap().trim_start_matches("0x");
|
|
let test_vector_bytes = hex::decode(ssz).unwrap();
|
|
|
|
// Convert test vector 'value' to ssz encoded bytes
|
|
let mut bytes: Vec<u8>;
|
|
match test_case["type"].as_str().unwrap() {
|
|
"uint8" => {
|
|
let value: u8 = test_case["value"].as_str().unwrap().parse::<u8>().unwrap();
|
|
bytes = ssz_encode::<u8>(&value); // check encoding
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u8>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
"uint16" => {
|
|
let value: u16 =
|
|
test_case["value"].as_str().unwrap().parse::<u16>().unwrap();
|
|
bytes = ssz_encode::<u16>(&value);
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u16>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
"uint32" => {
|
|
let value: u32 =
|
|
test_case["value"].as_str().unwrap().parse::<u32>().unwrap();
|
|
bytes = ssz_encode::<u32>(&value);
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u32>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
"uint64" => {
|
|
let value: u64 =
|
|
test_case["value"].as_str().unwrap().parse::<u64>().unwrap();
|
|
bytes = ssz_encode::<u64>(&value);
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u64>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
_ => continue,
|
|
};
|
|
assert_eq!(test_vector_bytes, bytes);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
pub fn test_vector_uint_random() {
|
|
let mut file = {
|
|
let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
|
file_path_buf.push("src/test_vectors/uint_random.yaml");
|
|
|
|
File::open(file_path_buf).unwrap()
|
|
};
|
|
let mut yaml_str = String::new();
|
|
file.read_to_string(&mut yaml_str).unwrap();
|
|
let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
|
|
let doc = &docs[0];
|
|
|
|
// Load test cases
|
|
let test_cases = doc["test_cases"].clone();
|
|
|
|
for test_case in test_cases {
|
|
// Only the valid cases are checked as parse::<uX>() will fail for all invalid cases
|
|
if test_case["valid"].as_bool().unwrap() {
|
|
// Convert test vector 'ssz' encoded yaml to Vec<u8>
|
|
let ssz = test_case["ssz"].as_str().unwrap().trim_start_matches("0x");
|
|
let test_vector_bytes = hex::decode(ssz).unwrap();
|
|
|
|
// Convert test vector 'value' to ssz encoded bytes
|
|
let mut bytes: Vec<u8>;
|
|
match test_case["type"].as_str().unwrap() {
|
|
"uint8" => {
|
|
let value: u8 = test_case["value"].as_str().unwrap().parse::<u8>().unwrap();
|
|
bytes = ssz_encode::<u8>(&value); // check encoding
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u8>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
"uint16" => {
|
|
let value: u16 =
|
|
test_case["value"].as_str().unwrap().parse::<u16>().unwrap();
|
|
bytes = ssz_encode::<u16>(&value);
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u16>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
"uint32" => {
|
|
let value: u32 =
|
|
test_case["value"].as_str().unwrap().parse::<u32>().unwrap();
|
|
bytes = ssz_encode::<u32>(&value);
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u32>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
"uint64" => {
|
|
let value: u64 =
|
|
test_case["value"].as_str().unwrap().parse::<u64>().unwrap();
|
|
bytes = ssz_encode::<u64>(&value);
|
|
|
|
// Check decoding
|
|
let decoded = decode::<u64>(&test_vector_bytes).unwrap();
|
|
assert_eq!(decoded, value);
|
|
}
|
|
_ => continue,
|
|
};
|
|
assert_eq!(test_vector_bytes, bytes);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
pub fn test_vector_uint_wrong_length() {
|
|
let mut file = {
|
|
let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
|
file_path_buf.push("src/test_vectors/uint_wrong_length.yaml");
|
|
|
|
File::open(file_path_buf).unwrap()
|
|
};
|
|
let mut yaml_str = String::new();
|
|
file.read_to_string(&mut yaml_str).unwrap();
|
|
let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
|
|
let doc = &docs[0];
|
|
|
|
// Load test cases
|
|
let test_cases = doc["test_cases"].clone();
|
|
|
|
for test_case in test_cases {
|
|
// Convert test vector 'ssz' encoded yaml to Vec<u8>
|
|
let ssz = test_case["ssz"].as_str().unwrap().trim_start_matches("0x");
|
|
let test_vector_bytes = hex::decode(ssz).unwrap();
|
|
|
|
// Attempt to decode invalid ssz bytes
|
|
match test_case["type"].as_str().unwrap() {
|
|
"uint8" => {
|
|
let decoded = decode::<u8>(&test_vector_bytes);
|
|
assert!(decoded.is_err());
|
|
}
|
|
"uint16" => {
|
|
let decoded = decode::<u16>(&test_vector_bytes);
|
|
assert!(decoded.is_err());
|
|
}
|
|
"uint32" => {
|
|
let decoded = decode::<u32>(&test_vector_bytes);
|
|
assert!(decoded.is_err());
|
|
}
|
|
"uint64" => {
|
|
let decoded = decode::<u64>(&test_vector_bytes);
|
|
assert!(decoded.is_err());
|
|
}
|
|
_ => continue,
|
|
};
|
|
}
|
|
}
|
|
}
|