2018-09-19 07:44:12 +00:00
|
|
|
use super::{
|
|
|
|
LENGTH_BYTES,
|
|
|
|
MAX_LIST_SIZE,
|
|
|
|
};
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum EncodeError {
|
|
|
|
ListTooLong,
|
|
|
|
}
|
2018-09-11 10:25:49 +00:00
|
|
|
|
|
|
|
pub trait Encodable {
|
|
|
|
fn ssz_append(&self, s: &mut SszStream);
|
|
|
|
}
|
|
|
|
|
2018-09-11 10:39:20 +00:00
|
|
|
/// Provides a buffer for appending ssz-encodable values.
|
|
|
|
///
|
|
|
|
/// Use the `append()` fn to add a value to a list, then use
|
|
|
|
/// the `drain()` method to consume the struct and return the
|
|
|
|
/// ssz encoded bytes.
|
2018-09-11 10:25:49 +00:00
|
|
|
pub struct SszStream {
|
|
|
|
buffer: Vec<u8>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SszStream {
|
2018-09-13 03:02:15 +00:00
|
|
|
/// Create a new, empty stream for writing ssz values.
|
2018-09-11 10:25:49 +00:00
|
|
|
pub fn new() -> Self {
|
|
|
|
SszStream {
|
|
|
|
buffer: Vec::new()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Append some ssz encodable value to the stream.
|
|
|
|
pub fn append<E>(&mut self, value: &E) -> &mut Self
|
|
|
|
where E: Encodable
|
|
|
|
{
|
|
|
|
value.ssz_append(self);
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2018-09-13 03:02:15 +00:00
|
|
|
/// Append some ssz encoded bytes to the stream.
|
2018-09-11 10:39:20 +00:00
|
|
|
///
|
|
|
|
/// The length of the supplied bytes will be concatenated
|
|
|
|
/// to the stream before the supplied bytes.
|
|
|
|
pub fn append_encoded_val(&mut self, vec: &Vec<u8>) {
|
2018-09-11 10:25:49 +00:00
|
|
|
self.buffer.extend_from_slice(
|
|
|
|
&encode_length(vec.len(),
|
|
|
|
LENGTH_BYTES));
|
|
|
|
self.buffer.extend_from_slice(&vec);
|
2018-09-17 06:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Append some ssz encoded bytes to the stream without calculating length
|
|
|
|
///
|
|
|
|
/// The raw bytes will be concatenated to the stream.
|
|
|
|
pub fn append_encoded_raw(&mut self, vec: &Vec<u8>) {
|
|
|
|
self.buffer.extend_from_slice(&vec);
|
2018-09-11 10:25:49 +00:00
|
|
|
}
|
|
|
|
|
2018-09-11 10:39:20 +00:00
|
|
|
/// Append some vector (list) of encodable values to the stream.
|
|
|
|
///
|
|
|
|
/// The length of the list will be concatenated to the stream, then
|
|
|
|
/// each item in the vector will be encoded and concatenated.
|
2018-09-11 10:25:49 +00:00
|
|
|
pub fn append_vec<E>(&mut self, vec: &Vec<E>)
|
|
|
|
where E: Encodable
|
|
|
|
{
|
2018-09-19 07:44:12 +00:00
|
|
|
let mut list_stream = SszStream::new();
|
|
|
|
for item in vec {
|
|
|
|
item.ssz_append(&mut list_stream);
|
|
|
|
}
|
2018-09-19 07:48:52 +00:00
|
|
|
self.append_encoded_val(&list_stream.drain());
|
2018-09-11 10:25:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Consume the stream and return the underlying bytes.
|
|
|
|
pub fn drain(self) -> Vec<u8> {
|
|
|
|
self.buffer
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-11 10:39:20 +00:00
|
|
|
/// Encode some length into a ssz size prefix.
|
|
|
|
///
|
|
|
|
/// The ssz size prefix is 4 bytes, which is treated as a continuious
|
|
|
|
/// 32bit big-endian integer.
|
2018-09-11 10:25:49 +00:00
|
|
|
pub fn encode_length(len: usize, length_bytes: usize) -> Vec<u8> {
|
|
|
|
assert!(length_bytes > 0); // For sanity
|
|
|
|
assert!((len as usize) < 2usize.pow(length_bytes as u32 * 8));
|
|
|
|
let mut header: Vec<u8> = vec![0; length_bytes];
|
|
|
|
for i in 0..length_bytes {
|
|
|
|
let offset = (length_bytes - i - 1) * 8;
|
|
|
|
header[i] = ((len >> offset) & 0xff) as u8;
|
|
|
|
};
|
|
|
|
header
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[should_panic]
|
|
|
|
fn test_encode_length_0_bytes_panic() {
|
|
|
|
encode_length(0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_encode_length_4_bytes() {
|
|
|
|
assert_eq!(
|
2018-09-12 07:57:07 +00:00
|
|
|
encode_length(0, LENGTH_BYTES),
|
2018-09-18 08:47:25 +00:00
|
|
|
vec![0; 4]
|
2018-09-11 10:25:49 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
2018-09-12 07:57:07 +00:00
|
|
|
encode_length(1, LENGTH_BYTES),
|
2018-09-18 08:47:25 +00:00
|
|
|
vec![0, 0, 0, 1]
|
2018-09-11 10:25:49 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
2018-09-12 07:57:07 +00:00
|
|
|
encode_length(255, LENGTH_BYTES),
|
2018-09-18 08:47:25 +00:00
|
|
|
vec![0, 0, 0, 255]
|
2018-09-11 10:25:49 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
2018-09-12 07:57:07 +00:00
|
|
|
encode_length(256, LENGTH_BYTES),
|
2018-09-18 08:47:25 +00:00
|
|
|
vec![0, 0, 1, 0]
|
2018-09-11 10:25:49 +00:00
|
|
|
);
|
|
|
|
assert_eq!(
|
2018-09-18 08:47:25 +00:00
|
|
|
encode_length(4294967295, LENGTH_BYTES), // 2^(3*8) - 1
|
|
|
|
vec![255, 255, 255, 255]
|
2018-09-11 10:25:49 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[should_panic]
|
|
|
|
fn test_encode_length_4_bytes_panic() {
|
2018-09-18 08:47:25 +00:00
|
|
|
encode_length(4294967296, LENGTH_BYTES); // 2^(3*8)
|
2018-09-11 10:25:49 +00:00
|
|
|
}
|
2018-09-19 07:44:12 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_encode_list() {
|
|
|
|
let test_vec: Vec<u16> = vec![256; 12];
|
|
|
|
let mut stream = SszStream::new();
|
2018-09-19 07:48:52 +00:00
|
|
|
stream.append_vec(&test_vec);
|
2018-09-19 07:44:12 +00:00
|
|
|
let ssz = stream.drain();
|
|
|
|
|
|
|
|
assert_eq!(ssz.len(), 4 + (12 * 2));
|
|
|
|
assert_eq!(ssz[0..4], *vec![0, 0, 0, 24]);
|
|
|
|
assert_eq!(ssz[4..6], *vec![1, 0]);
|
|
|
|
}
|
2018-09-11 10:25:49 +00:00
|
|
|
}
|