mirror of
https://github.com/0glabs/0g-storage-node.git
synced 2024-12-26 16:25:18 +00:00
266 lines
7.9 KiB
Rust
266 lines
7.9 KiB
Rust
//! Provides a "legacy" version of SSZ encoding for `Option<T> where T: Encode + Decode`.
|
|
//!
|
|
//! The SSZ specification changed in 2021 to use a 1-byte union selector, instead of a 4-byte one
|
|
//! which was used in the Lighthouse database.
|
|
//!
|
|
//! Users can use the `four_byte_option_impl` macro to define a module that can be used with the
|
|
//! `#[ssz(with = "module")]`.
|
|
//!
|
|
//! ## Example
|
|
//!
|
|
//! ```rust
|
|
//! use ssz_derive::{Encode, Decode};
|
|
//! use ssz::four_byte_option_impl;
|
|
//!
|
|
//! four_byte_option_impl!(impl_for_u64, u64);
|
|
//!
|
|
//! #[derive(Encode, Decode)]
|
|
//! struct Foo {
|
|
//! #[ssz(with = "impl_for_u64")]
|
|
//! a: Option<u64>,
|
|
//! }
|
|
//! ```
|
|
|
|
use crate::*;
|
|
|
|
#[macro_export]
|
|
macro_rules! four_byte_option_impl {
|
|
($mod_name: ident, $type: ty) => {
|
|
#[allow(dead_code)]
|
|
mod $mod_name {
|
|
use super::*;
|
|
|
|
pub mod encode {
|
|
use super::*;
|
|
#[allow(unused_imports)]
|
|
use ssz::*;
|
|
|
|
pub fn is_ssz_fixed_len() -> bool {
|
|
false
|
|
}
|
|
|
|
pub fn ssz_fixed_len() -> usize {
|
|
BYTES_PER_LENGTH_OFFSET
|
|
}
|
|
|
|
pub fn ssz_bytes_len(opt: &Option<$type>) -> usize {
|
|
if let Some(some) = opt {
|
|
let len = if <$type as Encode>::is_ssz_fixed_len() {
|
|
<$type as Encode>::ssz_fixed_len()
|
|
} else {
|
|
<$type as Encode>::ssz_bytes_len(some)
|
|
};
|
|
len + BYTES_PER_LENGTH_OFFSET
|
|
} else {
|
|
BYTES_PER_LENGTH_OFFSET
|
|
}
|
|
}
|
|
|
|
pub fn ssz_append(opt: &Option<$type>, buf: &mut Vec<u8>) {
|
|
match opt {
|
|
None => buf.extend_from_slice(&legacy::encode_four_byte_union_selector(0)),
|
|
Some(t) => {
|
|
buf.extend_from_slice(&legacy::encode_four_byte_union_selector(1));
|
|
t.ssz_append(buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn as_ssz_bytes(opt: &Option<$type>) -> Vec<u8> {
|
|
let mut buf = vec![];
|
|
|
|
ssz_append(opt, &mut buf);
|
|
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub mod decode {
|
|
use super::*;
|
|
#[allow(unused_imports)]
|
|
use ssz::*;
|
|
|
|
pub fn is_ssz_fixed_len() -> bool {
|
|
false
|
|
}
|
|
|
|
pub fn ssz_fixed_len() -> usize {
|
|
BYTES_PER_LENGTH_OFFSET
|
|
}
|
|
|
|
pub fn from_ssz_bytes(bytes: &[u8]) -> Result<Option<$type>, DecodeError> {
|
|
if bytes.len() < BYTES_PER_LENGTH_OFFSET {
|
|
return Err(DecodeError::InvalidByteLength {
|
|
len: bytes.len(),
|
|
expected: BYTES_PER_LENGTH_OFFSET,
|
|
});
|
|
}
|
|
|
|
let (index_bytes, value_bytes) = bytes.split_at(BYTES_PER_LENGTH_OFFSET);
|
|
|
|
let index = legacy::read_four_byte_union_selector(index_bytes)?;
|
|
if index == 0 {
|
|
Ok(None)
|
|
} else if index == 1 {
|
|
Ok(Some(<$type as ssz::Decode>::from_ssz_bytes(value_bytes)?))
|
|
} else {
|
|
Err(DecodeError::BytesInvalid(format!(
|
|
"{} is not a valid union index for Option<T>",
|
|
index
|
|
)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn encode_four_byte_union_selector(selector: usize) -> [u8; BYTES_PER_LENGTH_OFFSET] {
|
|
encode_length(selector)
|
|
}
|
|
|
|
pub fn read_four_byte_union_selector(bytes: &[u8]) -> Result<usize, DecodeError> {
|
|
read_offset(bytes)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate as ssz;
|
|
use ssz_derive::{Decode, Encode};
|
|
|
|
type VecU16 = Vec<u16>;
|
|
|
|
four_byte_option_impl!(impl_u16, u16);
|
|
four_byte_option_impl!(impl_vec_u16, VecU16);
|
|
|
|
#[test]
|
|
fn ssz_encode_option_u16() {
|
|
let item = Some(65535_u16);
|
|
let bytes = vec![1, 0, 0, 0, 255, 255];
|
|
assert_eq!(impl_u16::encode::as_ssz_bytes(&item), bytes);
|
|
assert_eq!(impl_u16::decode::from_ssz_bytes(&bytes).unwrap(), item);
|
|
|
|
let item = None;
|
|
let bytes = vec![0, 0, 0, 0];
|
|
assert_eq!(impl_u16::encode::as_ssz_bytes(&item), bytes);
|
|
assert_eq!(impl_u16::decode::from_ssz_bytes(&bytes).unwrap(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn ssz_encode_option_vec_u16() {
|
|
let item = Some(vec![0_u16, 1]);
|
|
let bytes = vec![1, 0, 0, 0, 0, 0, 1, 0];
|
|
assert_eq!(impl_vec_u16::encode::as_ssz_bytes(&item), bytes);
|
|
assert_eq!(impl_vec_u16::decode::from_ssz_bytes(&bytes).unwrap(), item);
|
|
|
|
let item = None;
|
|
let bytes = vec![0, 0, 0, 0];
|
|
assert_eq!(impl_vec_u16::encode::as_ssz_bytes(&item), bytes);
|
|
assert_eq!(impl_vec_u16::decode::from_ssz_bytes(&bytes).unwrap(), item);
|
|
}
|
|
|
|
fn round_trip<T: Encode + Decode + std::fmt::Debug + PartialEq>(items: Vec<T>) {
|
|
for item in items {
|
|
let encoded = &item.as_ssz_bytes();
|
|
assert_eq!(item.ssz_bytes_len(), encoded.len());
|
|
assert_eq!(T::from_ssz_bytes(encoded), Ok(item));
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Encode, Decode)]
|
|
struct TwoVariableLenOptions {
|
|
a: u16,
|
|
#[ssz(with = "impl_u16")]
|
|
b: Option<u16>,
|
|
#[ssz(with = "impl_vec_u16")]
|
|
c: Option<Vec<u16>>,
|
|
#[ssz(with = "impl_vec_u16")]
|
|
d: Option<Vec<u16>>,
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::zero_prefixed_literal)]
|
|
fn two_variable_len_options_encoding() {
|
|
let s = TwoVariableLenOptions {
|
|
a: 42,
|
|
b: None,
|
|
c: Some(vec![0]),
|
|
d: None,
|
|
};
|
|
|
|
let bytes = vec![
|
|
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
|
|
// | option<u16> | offset | offset | option<u16 | 1st list
|
|
42, 00, 14, 00, 00, 00, 18, 00, 00, 00, 24, 00, 00, 00, 00, 00, 00, 00, 01, 00, 00, 00,
|
|
// 23 24 25 26 27
|
|
// | 2nd list
|
|
00, 00, 00, 00, 00, 00,
|
|
];
|
|
|
|
assert_eq!(s.as_ssz_bytes(), bytes);
|
|
}
|
|
|
|
#[test]
|
|
fn two_variable_len_options_round_trip() {
|
|
let vec: Vec<TwoVariableLenOptions> = vec![
|
|
TwoVariableLenOptions {
|
|
a: 42,
|
|
b: Some(12),
|
|
c: Some(vec![0]),
|
|
d: Some(vec![1]),
|
|
},
|
|
TwoVariableLenOptions {
|
|
a: 42,
|
|
b: Some(12),
|
|
c: Some(vec![0]),
|
|
d: None,
|
|
},
|
|
TwoVariableLenOptions {
|
|
a: 42,
|
|
b: None,
|
|
c: Some(vec![0]),
|
|
d: None,
|
|
},
|
|
TwoVariableLenOptions {
|
|
a: 42,
|
|
b: None,
|
|
c: None,
|
|
d: None,
|
|
},
|
|
];
|
|
|
|
round_trip(vec);
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_u8_u16() {
|
|
let vec: Vec<(u8, u16)> = vec![
|
|
(0, 0),
|
|
(0, 1),
|
|
(1, 0),
|
|
(u8::max_value(), u16::max_value()),
|
|
(0, u16::max_value()),
|
|
(u8::max_value(), 0),
|
|
(42, 12301),
|
|
];
|
|
|
|
round_trip(vec);
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_vec_vec() {
|
|
let vec: Vec<(u64, Vec<u8>, Vec<Vec<u16>>)> = vec![
|
|
(0, vec![], vec![vec![]]),
|
|
(99, vec![101], vec![vec![], vec![]]),
|
|
(
|
|
42,
|
|
vec![12, 13, 14],
|
|
vec![vec![99, 98, 97, 96], vec![42, 44, 46, 48, 50]],
|
|
),
|
|
];
|
|
|
|
round_trip(vec);
|
|
}
|
|
}
|