Merge branch 'master' of github.com:gavofyork/ethcore-util into network
Conflicts: src/lib.rs src/rlp.rs src/triehash.rs
This commit is contained in:
arkpar
commit
ba4620bd6c
@ -16,10 +16,11 @@ rand = "0.3.12"
|
||||
time = "0.1.34"
|
||||
tiny-keccak = "1.0"
|
||||
rocksdb = "0.2.1"
|
||||
num = "0.1"
|
||||
lazy_static = "0.1.*"
|
||||
eth-secp256k1 = { git = "https://github.com/arkpar/rust-secp256k1.git" }
|
||||
rust-crypto = "0.2.34"
|
||||
elastic-array = "0.4"
|
||||
heapsize = "0.2"
|
||||
|
||||
[dev-dependencies]
|
||||
json-tests = { path = "json-tests" }
|
||||
|
||||
12
Makefile
Normal file
12
Makefile
Normal file
@ -0,0 +1,12 @@
|
||||
# Makefile for cross-compilation
|
||||
IOS_ARCHS = i386-apple-ios x86_64-apple-ios armv7-apple-ios armv7s-apple-ios aarch64-apple-ios
|
||||
IOS_LIB = libethcore_util.a
|
||||
|
||||
ios: $(IOS_LIB)
|
||||
|
||||
.PHONY: $(IOS_ARCHS)
|
||||
$(IOS_ARCHS): %:
|
||||
multirust run ios cargo build --target $@
|
||||
|
||||
$(IOS_LIB): $(IOS_ARCHS)
|
||||
lipo -create -output $@ $(foreach arch,$(IOS_ARCHS),$(wildcard target/$(arch)/debug/$(IOS_LIB)))
|
||||
@ -11,7 +11,7 @@ extern crate ethcore_util;
|
||||
|
||||
use test::Bencher;
|
||||
use std::str::FromStr;
|
||||
use ethcore_util::rlp::{RlpStream, Rlp, Decodable};
|
||||
use ethcore_util::rlp::*;
|
||||
use ethcore_util::uint::U256;
|
||||
|
||||
#[bench]
|
||||
@ -30,7 +30,7 @@ fn bench_decode_u64_value(b: &mut Bencher) {
|
||||
// u64
|
||||
let data = vec![0x88, 0x10, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
|
||||
let rlp = Rlp::new(&data);
|
||||
let _ = u64::decode(&rlp);
|
||||
let _: u64 = rlp.as_val();
|
||||
});
|
||||
}
|
||||
|
||||
@ -54,7 +54,7 @@ fn bench_decode_u256_value(b: &mut Bencher) {
|
||||
0x30, 0x40, 0x50, 0x60, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xf0];
|
||||
let rlp = Rlp::new(&data);
|
||||
let _ = U256::decode(&rlp);
|
||||
let _ : U256 = rlp.as_val();
|
||||
});
|
||||
}
|
||||
|
||||
@ -76,11 +76,11 @@ fn bench_decode_nested_empty_lists(b: &mut Bencher) {
|
||||
// [ [], [[]], [ [], [[]] ] ]
|
||||
let data = vec![0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0];
|
||||
let rlp = Rlp::new(&data);
|
||||
let _v0: Vec<u16> = Decodable::decode(&rlp.at(0));
|
||||
let _v1: Vec<Vec<u16>> = Decodable::decode(&rlp.at(1));
|
||||
let _v0: Vec<u16> = rlp.val_at(0);
|
||||
let _v1: Vec<Vec<u16>> = rlp.val_at(1);
|
||||
let nested_rlp = rlp.at(2);
|
||||
let _v2a: Vec<u16> = Decodable::decode(&nested_rlp.at(0));
|
||||
let _v2b: Vec<Vec<u16>> = Decodable::decode(&nested_rlp.at(1));
|
||||
let _v2a: Vec<u16> = nested_rlp.val_at(0);
|
||||
let _v2b: Vec<Vec<u16>> = nested_rlp.val_at(1);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
198
benches/trie.rs
Normal file
198
benches/trie.rs
Normal file
@ -0,0 +1,198 @@
|
||||
#![feature(test)]
|
||||
|
||||
extern crate test;
|
||||
extern crate rand;
|
||||
extern crate ethcore_util;
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
|
||||
use test::Bencher;
|
||||
use ethcore_util::hash::*;
|
||||
use ethcore_util::bytes::*;
|
||||
use ethcore_util::trie::*;
|
||||
use ethcore_util::hashdb::*;
|
||||
use ethcore_util::memorydb::*;
|
||||
use ethcore_util::triehash::*;
|
||||
use ethcore_util::sha3::*;
|
||||
|
||||
|
||||
fn random_word(alphabet: &[u8], min_count: usize, diff_count: usize, seed: &mut H256) -> Vec<u8> {
|
||||
assert!(min_count + diff_count <= 32);
|
||||
*seed = seed.sha3();
|
||||
let r = min_count + (seed.bytes()[31] as usize % (diff_count + 1));
|
||||
let mut ret: Vec<u8> = Vec::with_capacity(r);
|
||||
for i in 0..r {
|
||||
ret.push(alphabet[seed.bytes()[i] as usize % alphabet.len()]);
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
fn random_bytes(min_count: usize, diff_count: usize, seed: &mut H256) -> Vec<u8> {
|
||||
assert!(min_count + diff_count <= 32);
|
||||
*seed = seed.sha3();
|
||||
let r = min_count + (seed.bytes()[31] as usize % (diff_count + 1));
|
||||
seed.bytes()[0..r].to_vec()
|
||||
}
|
||||
|
||||
fn random_value(seed: &mut H256) -> Bytes {
|
||||
*seed = seed.sha3();
|
||||
match seed.bytes()[0] % 2 {
|
||||
1 => vec![seed.bytes()[31];1],
|
||||
_ => seed.bytes().to_vec(),
|
||||
}
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn trie_insertions_six_high(b: &mut Bencher) {
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_bytes(6, 0, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
|
||||
b.iter(||{
|
||||
let mut memdb = MemoryDB::new();
|
||||
let mut root = H256::new();
|
||||
let mut t = TrieDB::new(&mut memdb, &mut root);
|
||||
for i in d.iter() {
|
||||
t.insert(&i.0, &i.1);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn triehash_insertions_six_high(b: &mut Bencher) {
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_bytes(6, 0, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
|
||||
b.iter(&||{
|
||||
trie_root(d.clone());
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn trie_insertions_six_mid(b: &mut Bencher) {
|
||||
let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_word(alphabet, 6, 0, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
b.iter(||{
|
||||
let mut memdb = MemoryDB::new();
|
||||
let mut root = H256::new();
|
||||
let mut t = TrieDB::new(&mut memdb, &mut root);
|
||||
for i in d.iter() {
|
||||
t.insert(&i.0, &i.1);
|
||||
}
|
||||
debug!("hash_count={:?}", t.hash_count);
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn triehash_insertions_six_mid(b: &mut Bencher) {
|
||||
let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_word(alphabet, 6, 0, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
b.iter(||{
|
||||
trie_root(d.clone());
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn trie_insertions_random_mid(b: &mut Bencher) {
|
||||
let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_word(alphabet, 1, 5, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
|
||||
b.iter(||{
|
||||
let mut memdb = MemoryDB::new();
|
||||
let mut root = H256::new();
|
||||
let mut t = TrieDB::new(&mut memdb, &mut root);
|
||||
for i in d.iter() {
|
||||
t.insert(&i.0, &i.1);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn triehash_insertions_random_mid(b: &mut Bencher) {
|
||||
let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_word(alphabet, 1, 5, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
|
||||
b.iter(||{
|
||||
trie_root(d.clone());
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn trie_insertions_six_low(b: &mut Bencher) {
|
||||
let alphabet = b"abcdef";
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_word(alphabet, 6, 0, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
|
||||
b.iter(||{
|
||||
let mut memdb = MemoryDB::new();
|
||||
let mut root = H256::new();
|
||||
let mut t = TrieDB::new(&mut memdb, &mut root);
|
||||
for i in d.iter() {
|
||||
t.insert(&i.0, &i.1);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn triehash_insertions_six_low(b: &mut Bencher) {
|
||||
let alphabet = b"abcdef";
|
||||
let mut d: Vec<(Bytes, Bytes)> = Vec::new();
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
let k = random_word(alphabet, 6, 0, &mut seed);
|
||||
let v = random_value(&mut seed);
|
||||
d.push((k, v))
|
||||
}
|
||||
|
||||
b.iter(||{
|
||||
trie_root(d.clone());
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn sha3x1000(b: &mut Bencher) {
|
||||
b.iter(||{
|
||||
let mut seed = H256::new();
|
||||
for _ in 0..1000 {
|
||||
seed = seed.sha3()
|
||||
}
|
||||
})
|
||||
}
|
||||
@ -41,7 +41,6 @@
|
||||
use std::collections::{HashMap};
|
||||
use hash::*;
|
||||
use sha3::*;
|
||||
use num::pow;
|
||||
|
||||
/// Represents bloom index in cache
|
||||
///
|
||||
@ -119,13 +118,21 @@ impl<'a, D> ChainFilter<'a, D> where D: FilterDataSource
|
||||
let mut filter = ChainFilter {
|
||||
data_source: data_source,
|
||||
index_size: index_size,
|
||||
level_sizes: vec![]
|
||||
// 0 level has always a size of 1
|
||||
level_sizes: vec![1]
|
||||
};
|
||||
|
||||
// cache level sizes, so we do not have to calculate them all the time
|
||||
for i in 0..levels {
|
||||
filter.level_sizes.push(pow(index_size, i as usize));
|
||||
}
|
||||
// eg. if levels == 3, index_size = 16
|
||||
// level_sizes = [1, 16, 256]
|
||||
let additional: Vec<usize> = (1..).into_iter()
|
||||
.scan(1, |acc, _| {
|
||||
*acc = *acc * index_size;
|
||||
Some(*acc)
|
||||
})
|
||||
.take(levels as usize - 1)
|
||||
.collect();
|
||||
filter.level_sizes.extend(additional);
|
||||
|
||||
filter
|
||||
}
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
//! General error types for use in ethcore.
|
||||
|
||||
use rustc_serialize::hex::*;
|
||||
|
||||
#[derive(Debug)]
|
||||
@ -6,6 +8,7 @@ pub enum BaseDataError {
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
/// General error type which should be capable of representing all errors in ethcore.
|
||||
pub enum EthcoreError {
|
||||
FromHex(FromHexError),
|
||||
BaseData(BaseDataError),
|
||||
|
||||
17
src/hash.rs
17
src/hash.rs
@ -1,3 +1,5 @@
|
||||
//! General hash types, a fixed-size raw-data type used as the output of hash functions.
|
||||
|
||||
use std::str::FromStr;
|
||||
use std::fmt;
|
||||
use std::ops;
|
||||
@ -11,7 +13,9 @@ use bytes::BytesConvertable;
|
||||
use math::log2;
|
||||
use uint::U256;
|
||||
|
||||
/// types implementing FixedHash must be also BytesConvertable
|
||||
/// Trait for a fixed-size byte array to be used as the output of hash functions.
|
||||
///
|
||||
/// Note: types implementing `FixedHash` must be also `BytesConvertable`.
|
||||
pub trait FixedHash: Sized + BytesConvertable {
|
||||
fn new() -> Self;
|
||||
fn random() -> Self;
|
||||
@ -40,19 +44,17 @@ macro_rules! impl_hash {
|
||||
|
||||
impl Deref for $from {
|
||||
type Target = [u8];
|
||||
|
||||
#[inline]
|
||||
fn deref(&self) -> &[u8] {
|
||||
unsafe {
|
||||
::std::slice::from_raw_parts(self.0.as_ptr(), $size)
|
||||
}
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl DerefMut for $from {
|
||||
|
||||
#[inline]
|
||||
fn deref_mut(&mut self) -> &mut [u8] {
|
||||
unsafe {
|
||||
::std::slice::from_raw_parts_mut(self.0.as_mut_ptr(), $size)
|
||||
}
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
|
||||
@ -355,6 +357,7 @@ impl_hash!(H64, 8);
|
||||
impl_hash!(H128, 16);
|
||||
impl_hash!(Address, 20);
|
||||
impl_hash!(H256, 32);
|
||||
impl_hash!(H264, 33);
|
||||
impl_hash!(H512, 64);
|
||||
impl_hash!(H520, 65);
|
||||
impl_hash!(H1024, 128);
|
||||
|
||||
@ -1,10 +1,12 @@
|
||||
//! Database of byte-slices keyed to their Keccak hash.
|
||||
use hash::*;
|
||||
use bytes::*;
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Trait modelling datastore keyed by a 32-byte Keccak hash.
|
||||
pub trait HashDB {
|
||||
/// Get the keys in the database together with number of underlying references.
|
||||
fn keys(&self) -> HashMap<H256, u32>;
|
||||
fn keys(&self) -> HashMap<H256, i32>;
|
||||
|
||||
/// Look up a given hash into the bytes that hash to it, returning None if the
|
||||
/// hash is not known.
|
||||
|
||||
5
src/heapsizeof.rs
Normal file
5
src/heapsizeof.rs
Normal file
@ -0,0 +1,5 @@
|
||||
use uint::*;
|
||||
use hash::*;
|
||||
|
||||
known_heap_size!(0, H32, H64, H128, Address, H256, H264, H512, H520, H1024, H2048);
|
||||
known_heap_size!(0, U128, U256);
|
||||
47
src/lib.rs
47
src/lib.rs
@ -1,32 +1,59 @@
|
||||
//! Ethcore-util library
|
||||
//!
|
||||
//! TODO: check reexports
|
||||
//!
|
||||
//! ### Rust version:
|
||||
//! - beta
|
||||
//! - nightly
|
||||
//!
|
||||
//! ### Supported platforms:
|
||||
//! - OSX
|
||||
//! - Linux
|
||||
//!
|
||||
//! ### Dependencies:
|
||||
//! - RocksDB 3.13
|
||||
//!
|
||||
//! ### Dependencies Installation:
|
||||
//!
|
||||
//! - OSX:
|
||||
//!
|
||||
//! ```bash
|
||||
//! brew install rocksdb
|
||||
//! ```
|
||||
//!
|
||||
//! - From source:
|
||||
//!
|
||||
//! ```bash
|
||||
//! wget https://github.com/facebook/rocksdb/archive/rocksdb-3.13.tar.gz
|
||||
//! tar xvf rocksdb-3.13.tar.gz && cd rocksdb-rocksdb-3.13 && make shared_lib
|
||||
//! sudo make install
|
||||
//! ```
|
||||
|
||||
extern crate rustc_serialize;
|
||||
extern crate mio;
|
||||
extern crate rand;
|
||||
extern crate rocksdb;
|
||||
extern crate tiny_keccak;
|
||||
extern crate num;
|
||||
|
||||
#[macro_use]
|
||||
extern crate heapsize;
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
|
||||
extern crate env_logger;
|
||||
|
||||
extern crate time;
|
||||
extern crate crypto as rcrypto;
|
||||
extern crate secp256k1;
|
||||
extern crate arrayvec;
|
||||
extern crate elastic_array;
|
||||
|
||||
pub mod macros;
|
||||
pub mod error;
|
||||
pub mod hash;
|
||||
pub mod uint;
|
||||
pub mod bytes;
|
||||
pub mod rlp;
|
||||
pub mod vector;
|
||||
pub mod db;
|
||||
pub mod sha3;
|
||||
pub mod hashdb;
|
||||
pub mod memorydb;
|
||||
@ -37,14 +64,8 @@ pub mod crypto;
|
||||
pub mod triehash;
|
||||
pub mod trie;
|
||||
pub mod nibbleslice;
|
||||
pub mod heapsizeof;
|
||||
pub mod squeeze;
|
||||
|
||||
pub mod network;
|
||||
|
||||
// reexports
|
||||
pub use std::str::FromStr;
|
||||
pub use hash::*;
|
||||
pub use sha3::*;
|
||||
pub use bytes::*;
|
||||
pub use hashdb::*;
|
||||
pub use memorydb::*;
|
||||
|
||||
|
||||
@ -1,11 +0,0 @@
|
||||
macro_rules! map(
|
||||
{ $($key:expr => $value:expr),+ } => {
|
||||
{
|
||||
let mut m = ::std::collections::HashMap::new();
|
||||
$(
|
||||
m.insert($key, $value);
|
||||
)+
|
||||
m
|
||||
}
|
||||
};
|
||||
);
|
||||
@ -116,10 +116,6 @@ impl MemoryDB {
|
||||
}
|
||||
self.data.get(key).unwrap()
|
||||
}
|
||||
|
||||
pub fn raw_keys(&self) -> HashMap<H256, i32> {
|
||||
self.data.iter().filter_map(|(k, v)| if v.1 != 0 {Some((k.clone(), v.1))} else {None}).collect::<HashMap<H256, i32>>()
|
||||
}
|
||||
}
|
||||
|
||||
impl HashDB for MemoryDB {
|
||||
@ -130,8 +126,8 @@ impl HashDB for MemoryDB {
|
||||
}
|
||||
}
|
||||
|
||||
fn keys(&self) -> HashMap<H256, u32> {
|
||||
self.data.iter().filter_map(|(k, v)| if v.1 > 0 {Some((k.clone(), v.1 as u32))} else {None} ).collect::<HashMap<H256, u32>>()
|
||||
fn keys(&self) -> HashMap<H256, i32> {
|
||||
self.data.iter().filter_map(|(k, v)| if v.1 != 0 {Some((k.clone(), v.1))} else {None}).collect::<HashMap<H256, i32>>()
|
||||
}
|
||||
|
||||
fn exists(&self, key: &H256) -> bool {
|
||||
|
||||
@ -122,7 +122,7 @@ impl OverlayDB {
|
||||
.expect("Low-level database error. Some issue with your hard disk?")
|
||||
.map(|d| {
|
||||
let r = Rlp::new(d.deref());
|
||||
(Bytes::decode(&r.at(1)), u32::decode(&r.at(0)))
|
||||
(r.at(1).as_val(), r.at(0).as_val())
|
||||
})
|
||||
}
|
||||
|
||||
@ -136,17 +136,17 @@ impl OverlayDB {
|
||||
}
|
||||
|
||||
impl HashDB for OverlayDB {
|
||||
fn keys(&self) -> HashMap<H256, u32> {
|
||||
let mut ret: HashMap<H256, u32> = HashMap::new();
|
||||
fn keys(&self) -> HashMap<H256, i32> {
|
||||
let mut ret: HashMap<H256, i32> = HashMap::new();
|
||||
for (key, _) in self.backing.iterator().from_start() {
|
||||
let h = H256::from_slice(key.deref());
|
||||
let r = self.payload(&h).unwrap().1;
|
||||
ret.insert(h, r);
|
||||
ret.insert(h, r as i32);
|
||||
}
|
||||
|
||||
for (key, refs) in self.overlay.raw_keys().into_iter() {
|
||||
let refs = *ret.get(&key).unwrap_or(&0u32) as i32 + refs as i32;
|
||||
ret.insert(key, refs as u32);
|
||||
for (key, refs) in self.overlay.keys().into_iter() {
|
||||
let refs = *ret.get(&key).unwrap_or(&0) + refs;
|
||||
ret.insert(key, refs);
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
1443
src/rlp.rs
1443
src/rlp.rs
File diff suppressed because it is too large
Load Diff
30
src/rlp/errors.rs
Normal file
30
src/rlp/errors.rs
Normal file
@ -0,0 +1,30 @@
|
||||
use std::fmt;
|
||||
use std::error::Error as StdError;
|
||||
use bytes::FromBytesError;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum DecoderError {
|
||||
FromBytesError(FromBytesError),
|
||||
RlpIsTooShort,
|
||||
RlpExpectedToBeList,
|
||||
RlpExpectedToBeData,
|
||||
RlpIncorrectListLen
|
||||
}
|
||||
|
||||
impl StdError for DecoderError {
|
||||
fn description(&self) -> &str {
|
||||
"builder error"
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for DecoderError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt::Debug::fmt(&self, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<FromBytesError> for DecoderError {
|
||||
fn from(err: FromBytesError) -> DecoderError {
|
||||
DecoderError::FromBytesError(err)
|
||||
}
|
||||
}
|
||||
81
src/rlp/mod.rs
Normal file
81
src/rlp/mod.rs
Normal file
@ -0,0 +1,81 @@
|
||||
//! Rlp serialization module
|
||||
//!
|
||||
//! Allows encoding, decoding, and view onto rlp-slice
|
||||
//!
|
||||
//!# What should you use when?
|
||||
//!
|
||||
//!### Use `encode` function when:
|
||||
//! * You want to encode something inline.
|
||||
//! * You do not work on big set of data.
|
||||
//! * You want to encode whole data structure at once.
|
||||
//!
|
||||
//!### Use `decode` function when:
|
||||
//! * You want to decode something inline.
|
||||
//! * You do not work on big set of data.
|
||||
//! * You want to decode whole rlp at once.
|
||||
//!
|
||||
//!### Use `RlpStream` when:
|
||||
//! * You want to encode something in portions.
|
||||
//! * You encode a big set of data.
|
||||
//!
|
||||
//!### Use `Rlp` when:
|
||||
//! * You are working on trusted data (not corrupted).
|
||||
//! * You want to get view onto rlp-slice.
|
||||
//! * You don't want to decode whole rlp at once.
|
||||
//!
|
||||
//!### Use `UntrustedRlp` when:
|
||||
//! * You are working on untrusted data (~corrupted).
|
||||
//! * You need to handle data corruption errors.
|
||||
//! * You are working on input data.
|
||||
//! * You want to get view onto rlp-slice.
|
||||
//! * You don't want to decode whole rlp at once.
|
||||
|
||||
pub mod errors;
|
||||
pub mod traits;
|
||||
pub mod rlp;
|
||||
pub mod untrusted_rlp;
|
||||
pub mod rlpstream;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
pub use self::errors::DecoderError;
|
||||
pub use self::traits::{Decoder, Decodable, View, Stream, Encodable, Encoder};
|
||||
pub use self::untrusted_rlp::{UntrustedRlp, UntrustedRlpIterator, PayloadInfo, Prototype};
|
||||
pub use self::rlp::{Rlp, RlpIterator};
|
||||
pub use self::rlpstream::{RlpStream};
|
||||
|
||||
/// Shortcut function to decode trusted rlp
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let animals: Vec<String> = decode(&data);
|
||||
/// assert_eq!(animals, vec!["cat".to_string(), "dog".to_string()]);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn decode<T>(bytes: &[u8]) -> T where T: Decodable {
|
||||
let rlp = Rlp::new(bytes);
|
||||
rlp.as_val()
|
||||
}
|
||||
|
||||
/// Shortcut function to encode structure into rlp.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let animals = vec!["cat", "dog"];
|
||||
/// let out = encode(&animals);
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn encode<E>(object: &E) -> Vec<u8> where E: Encodable {
|
||||
let mut stream = RlpStream::new();
|
||||
stream.append(object);
|
||||
stream.out()
|
||||
}
|
||||
135
src/rlp/rlp.rs
Normal file
135
src/rlp/rlp.rs
Normal file
@ -0,0 +1,135 @@
|
||||
use rlp::{View, Decodable, DecoderError, UntrustedRlp, PayloadInfo, Prototype};
|
||||
|
||||
impl<'a> From<UntrustedRlp<'a>> for Rlp<'a> {
|
||||
fn from(rlp: UntrustedRlp<'a>) -> Rlp<'a> {
|
||||
Rlp { rlp: rlp }
|
||||
}
|
||||
}
|
||||
|
||||
/// Data-oriented view onto trusted rlp-slice.
|
||||
///
|
||||
/// Unlikely to `UntrustedRlp` doesn't bother you with error
|
||||
/// handling. It assumes that you know what you are doing.
|
||||
#[derive(Debug)]
|
||||
pub struct Rlp<'a> {
|
||||
rlp: UntrustedRlp<'a>
|
||||
}
|
||||
|
||||
impl<'a, 'view> View<'a, 'view> for Rlp<'a> where 'a: 'view {
|
||||
type Prototype = Prototype;
|
||||
type PayloadInfo = PayloadInfo;
|
||||
type Data = &'a [u8];
|
||||
type Item = Rlp<'a>;
|
||||
type Iter = RlpIterator<'a, 'view>;
|
||||
|
||||
/// Create a new instance of `Rlp`
|
||||
fn new(bytes: &'a [u8]) -> Rlp<'a> {
|
||||
Rlp {
|
||||
rlp: UntrustedRlp::new(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
fn raw(&'view self) -> &'a [u8] {
|
||||
self.rlp.raw()
|
||||
}
|
||||
|
||||
fn prototype(&self) -> Self::Prototype {
|
||||
self.rlp.prototype().unwrap()
|
||||
}
|
||||
|
||||
fn payload_info(&self) -> Self::PayloadInfo {
|
||||
self.rlp.payload_info().unwrap()
|
||||
}
|
||||
|
||||
fn data(&'view self) -> Self::Data {
|
||||
self.rlp.data().unwrap()
|
||||
}
|
||||
|
||||
fn item_count(&self) -> usize {
|
||||
self.rlp.item_count()
|
||||
}
|
||||
|
||||
fn size(&self) -> usize {
|
||||
self.rlp.size()
|
||||
}
|
||||
|
||||
fn at(&'view self, index: usize) -> Self::Item {
|
||||
From::from(self.rlp.at(index).unwrap())
|
||||
}
|
||||
|
||||
fn is_null(&self) -> bool {
|
||||
self.rlp.is_null()
|
||||
}
|
||||
|
||||
fn is_empty(&self) -> bool {
|
||||
self.rlp.is_empty()
|
||||
}
|
||||
|
||||
fn is_list(&self) -> bool {
|
||||
self.rlp.is_list()
|
||||
}
|
||||
|
||||
fn is_data(&self) -> bool {
|
||||
self.rlp.is_data()
|
||||
}
|
||||
|
||||
fn is_int(&self) -> bool {
|
||||
self.rlp.is_int()
|
||||
}
|
||||
|
||||
fn iter(&'view self) -> Self::Iter {
|
||||
self.into_iter()
|
||||
}
|
||||
|
||||
fn as_val<T>(&self) -> Result<T, DecoderError> where T: Decodable {
|
||||
self.rlp.as_val()
|
||||
}
|
||||
|
||||
fn val_at<T>(&self, index: usize) -> Result<T, DecoderError> where T: Decodable {
|
||||
self.at(index).rlp.as_val()
|
||||
}
|
||||
}
|
||||
|
||||
impl <'a, 'view> Rlp<'a> where 'a: 'view {
|
||||
fn view_as_val<T, R>(r: &R) -> T where R: View<'a, 'view>, T: Decodable {
|
||||
let res: Result<T, DecoderError> = r.as_val();
|
||||
res.unwrap_or_else(|_| panic!())
|
||||
}
|
||||
|
||||
pub fn as_val<T>(&self) -> T where T: Decodable {
|
||||
Self::view_as_val(self)
|
||||
}
|
||||
|
||||
pub fn val_at<T>(&self, index: usize) -> T where T: Decodable {
|
||||
Self::view_as_val(&self.at(index))
|
||||
}
|
||||
}
|
||||
|
||||
/// Iterator over trusted rlp-slice list elements.
|
||||
pub struct RlpIterator<'a, 'view> where 'a: 'view {
|
||||
rlp: &'view Rlp<'a>,
|
||||
index: usize
|
||||
}
|
||||
|
||||
impl<'a, 'view> IntoIterator for &'view Rlp<'a> where 'a: 'view {
|
||||
type Item = Rlp<'a>;
|
||||
type IntoIter = RlpIterator<'a, 'view>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
RlpIterator {
|
||||
rlp: self,
|
||||
index: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'view> Iterator for RlpIterator<'a, 'view> {
|
||||
type Item = Rlp<'a>;
|
||||
|
||||
fn next(&mut self) -> Option<Rlp<'a>> {
|
||||
let index = self.index;
|
||||
let result = self.rlp.rlp.at(index).ok().map(| iter | { From::from(iter) });
|
||||
self.index += 1;
|
||||
result
|
||||
}
|
||||
}
|
||||
260
src/rlp/rlpstream.rs
Normal file
260
src/rlp/rlpstream.rs
Normal file
@ -0,0 +1,260 @@
|
||||
use elastic_array::*;
|
||||
use bytes::ToBytes;
|
||||
use rlp::{Stream, Encoder, Encodable};
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
struct ListInfo {
|
||||
position: usize,
|
||||
current: usize,
|
||||
max: usize,
|
||||
}
|
||||
|
||||
impl ListInfo {
|
||||
fn new(position: usize, max: usize) -> ListInfo {
|
||||
ListInfo {
|
||||
position: position,
|
||||
current: 0,
|
||||
max: max,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Appendable rlp encoder.
|
||||
pub struct RlpStream {
|
||||
unfinished_lists: ElasticArray16<ListInfo>,
|
||||
encoder: BasicEncoder,
|
||||
}
|
||||
|
||||
impl Stream for RlpStream {
|
||||
fn new() -> Self {
|
||||
RlpStream {
|
||||
unfinished_lists: ElasticArray16::new(),
|
||||
encoder: BasicEncoder::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn new_list(len: usize) -> Self {
|
||||
let mut stream = RlpStream::new();
|
||||
stream.append_list(len);
|
||||
stream
|
||||
}
|
||||
|
||||
fn append<'a, E>(&'a mut self, object: &E) -> &'a mut RlpStream where E: Encodable {
|
||||
// encode given value and add it at the end of the stream
|
||||
object.encode(&mut self.encoder);
|
||||
|
||||
// if list is finished, prepend the length
|
||||
self.note_appended(1);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn append_list<'a>(&'a mut self, len: usize) -> &'a mut RlpStream {
|
||||
match len {
|
||||
0 => {
|
||||
// we may finish, if the appended list len is equal 0
|
||||
self.encoder.bytes.push(0xc0u8);
|
||||
self.note_appended(1);
|
||||
},
|
||||
_ => {
|
||||
let position = self.encoder.bytes.len();
|
||||
self.unfinished_lists.push(ListInfo::new(position, len));
|
||||
},
|
||||
}
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn append_empty_data<'a>(&'a mut self) -> &'a mut RlpStream {
|
||||
// self push raw item
|
||||
self.encoder.bytes.push(0x80);
|
||||
|
||||
// try to finish and prepend the length
|
||||
self.note_appended(1);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut RlpStream {
|
||||
// push raw items
|
||||
self.encoder.bytes.append_slice(bytes);
|
||||
|
||||
// try to finish and prepend the length
|
||||
self.note_appended(item_count);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn clear(&mut self) {
|
||||
// clear bytes
|
||||
self.encoder.bytes.clear();
|
||||
|
||||
// clear lists
|
||||
self.unfinished_lists.clear();
|
||||
}
|
||||
|
||||
fn is_finished(&self) -> bool {
|
||||
self.unfinished_lists.len() == 0
|
||||
}
|
||||
|
||||
fn raw(&self) -> &[u8] {
|
||||
&self.encoder.bytes
|
||||
}
|
||||
|
||||
fn out(self) -> Vec<u8> {
|
||||
match self.is_finished() {
|
||||
true => self.encoder.out().to_vec(),
|
||||
false => panic!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RlpStream {
|
||||
|
||||
/// Try to finish lists
|
||||
fn note_appended(&mut self, inserted_items: usize) -> () {
|
||||
if self.unfinished_lists.len() == 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
let back = self.unfinished_lists.len() - 1;
|
||||
let should_finish = match self.unfinished_lists.get_mut(back) {
|
||||
None => false,
|
||||
Some(ref mut x) => {
|
||||
x.current += inserted_items;
|
||||
if x.current > x.max {
|
||||
panic!("You cannot append more items then you expect!");
|
||||
}
|
||||
x.current == x.max
|
||||
}
|
||||
};
|
||||
|
||||
if should_finish {
|
||||
let x = self.unfinished_lists.pop().unwrap();
|
||||
let len = self.encoder.bytes.len() - x.position;
|
||||
self.encoder.insert_list_len_at_pos(len, x.position);
|
||||
self.note_appended(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct BasicEncoder {
|
||||
bytes: ElasticArray1024<u8>,
|
||||
}
|
||||
|
||||
impl BasicEncoder {
|
||||
fn new() -> BasicEncoder {
|
||||
BasicEncoder { bytes: ElasticArray1024::new() }
|
||||
}
|
||||
|
||||
/// inserts list prefix at given position
|
||||
/// TODO: optimise it further?
|
||||
fn insert_list_len_at_pos(&mut self, len: usize, pos: usize) -> () {
|
||||
let mut res = vec![];
|
||||
match len {
|
||||
0...55 => res.push(0xc0u8 + len as u8),
|
||||
_ => {
|
||||
res.push(0xf7u8 + len.to_bytes_len() as u8);
|
||||
res.extend(len.to_bytes());
|
||||
}
|
||||
};
|
||||
|
||||
self.bytes.insert_slice(pos, &res);
|
||||
}
|
||||
|
||||
/// get encoded value
|
||||
fn out(self) -> ElasticArray1024<u8> {
|
||||
self.bytes
|
||||
}
|
||||
}
|
||||
|
||||
impl Encoder for BasicEncoder {
|
||||
fn emit_value(&mut self, bytes: &[u8]) -> () {
|
||||
match bytes.len() {
|
||||
// just 0
|
||||
0 => self.bytes.push(0x80u8),
|
||||
// byte is its own encoding
|
||||
1 if bytes[0] < 0x80 => self.bytes.append_slice(bytes),
|
||||
// (prefix + length), followed by the string
|
||||
len @ 1 ... 55 => {
|
||||
self.bytes.push(0x80u8 + len as u8);
|
||||
self.bytes.append_slice(bytes);
|
||||
}
|
||||
// (prefix + length of length), followed by the length, followd by the string
|
||||
len => {
|
||||
self.bytes.push(0xb7 + len.to_bytes_len() as u8);
|
||||
self.bytes.append_slice(&len.to_bytes());
|
||||
self.bytes.append_slice(bytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_list<F>(&mut self, f: F) -> () where F: FnOnce(&mut Self) -> ()
|
||||
{
|
||||
// get len before inserting a list
|
||||
let before_len = self.bytes.len();
|
||||
|
||||
// insert all list elements
|
||||
f(self);
|
||||
|
||||
// get len after inserting a list
|
||||
let after_len = self.bytes.len();
|
||||
|
||||
// diff is list len
|
||||
let list_len = after_len - before_len;
|
||||
self.insert_list_len_at_pos(list_len, before_len);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for T where T: ToBytes {
|
||||
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
||||
encoder.emit_value(&self.to_bytes())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T> Encodable for &'a [T] where T: Encodable + 'a {
|
||||
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
||||
encoder.emit_list(|e| {
|
||||
// insert all list elements
|
||||
for el in self.iter() {
|
||||
el.encode(e);
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for Vec<T> where T: Encodable {
|
||||
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
||||
let r: &[T] = self.as_ref();
|
||||
r.encode(encoder)
|
||||
}
|
||||
}
|
||||
|
||||
/// lets treat bytes differently than other lists
|
||||
/// they are a single value
|
||||
impl<'a> Encodable for &'a [u8] {
|
||||
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
||||
encoder.emit_value(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// lets treat bytes differently than other lists
|
||||
/// they are a single value
|
||||
impl Encodable for Vec<u8> {
|
||||
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
||||
encoder.emit_value(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for Option<T> where T: Encodable {
|
||||
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
||||
match *self {
|
||||
Some(ref x) => x.encode(encoder),
|
||||
None => encoder.emit_value(&[])
|
||||
}
|
||||
}
|
||||
}
|
||||
353
src/rlp/tests.rs
Normal file
353
src/rlp/tests.rs
Normal file
@ -0,0 +1,353 @@
|
||||
extern crate json_tests;
|
||||
use self::json_tests::execute_tests_from_directory;
|
||||
use self::json_tests::rlp as rlptest;
|
||||
use std::{fmt, cmp};
|
||||
use std::str::FromStr;
|
||||
use rlp;
|
||||
use rlp::{UntrustedRlp, RlpStream, Decodable, View, Stream, Encodable};
|
||||
use uint::U256;
|
||||
|
||||
#[test]
|
||||
fn rlp_at() {
|
||||
let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
{
|
||||
let rlp = UntrustedRlp::new(&data);
|
||||
assert!(rlp.is_list());
|
||||
//let animals = <Vec<String> as rlp::Decodable>::decode_untrusted(&rlp).unwrap();
|
||||
let animals: Vec<String> = rlp.as_val().unwrap();
|
||||
assert_eq!(animals, vec!["cat".to_string(), "dog".to_string()]);
|
||||
|
||||
let cat = rlp.at(0).unwrap();
|
||||
assert!(cat.is_data());
|
||||
assert_eq!(cat.raw(), &[0x83, b'c', b'a', b't']);
|
||||
//assert_eq!(String::decode_untrusted(&cat).unwrap(), "cat".to_string());
|
||||
assert_eq!(cat.as_val::<String>().unwrap(), "cat".to_string());
|
||||
|
||||
let dog = rlp.at(1).unwrap();
|
||||
assert!(dog.is_data());
|
||||
assert_eq!(dog.raw(), &[0x83, b'd', b'o', b'g']);
|
||||
//assert_eq!(String::decode_untrusted(&dog).unwrap(), "dog".to_string());
|
||||
assert_eq!(dog.as_val::<String>().unwrap(), "dog".to_string());
|
||||
|
||||
let cat_again = rlp.at(0).unwrap();
|
||||
assert!(cat_again.is_data());
|
||||
assert_eq!(cat_again.raw(), &[0x83, b'c', b'a', b't']);
|
||||
//assert_eq!(String::decode_untrusted(&cat_again).unwrap(), "cat".to_string());
|
||||
assert_eq!(cat_again.as_val::<String>().unwrap(), "cat".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rlp_at_err() {
|
||||
let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o'];
|
||||
{
|
||||
let rlp = UntrustedRlp::new(&data);
|
||||
assert!(rlp.is_list());
|
||||
|
||||
let cat_err = rlp.at(0).unwrap_err();
|
||||
assert_eq!(cat_err, rlp::DecoderError::RlpIsTooShort);
|
||||
|
||||
let dog_err = rlp.at(1).unwrap_err();
|
||||
assert_eq!(dog_err, rlp::DecoderError::RlpIsTooShort);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rlp_iter() {
|
||||
let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
{
|
||||
let rlp = UntrustedRlp::new(&data);
|
||||
let mut iter = rlp.iter();
|
||||
|
||||
let cat = iter.next().unwrap();
|
||||
assert!(cat.is_data());
|
||||
assert_eq!(cat.raw(), &[0x83, b'c', b'a', b't']);
|
||||
|
||||
let dog = iter.next().unwrap();
|
||||
assert!(dog.is_data());
|
||||
assert_eq!(dog.raw(), &[0x83, b'd', b'o', b'g']);
|
||||
|
||||
let none = iter.next();
|
||||
assert!(none.is_none());
|
||||
|
||||
let cat_again = rlp.at(0).unwrap();
|
||||
assert!(cat_again.is_data());
|
||||
assert_eq!(cat_again.raw(), &[0x83, b'c', b'a', b't']);
|
||||
}
|
||||
}
|
||||
|
||||
struct ETestPair<T>(T, Vec<u8>) where T: rlp::Encodable;
|
||||
|
||||
fn run_encode_tests<T>(tests: Vec<ETestPair<T>>)
|
||||
where T: rlp::Encodable
|
||||
{
|
||||
for t in &tests {
|
||||
let res = rlp::encode(&t.0);
|
||||
assert_eq!(res, &t.1[..]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_u16() {
|
||||
let tests = vec![
|
||||
ETestPair(0u16, vec![0x80u8]),
|
||||
ETestPair(0x100, vec![0x82, 0x01, 0x00]),
|
||||
ETestPair(0xffff, vec![0x82, 0xff, 0xff]),
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_u32() {
|
||||
let tests = vec![
|
||||
ETestPair(0u32, vec![0x80u8]),
|
||||
ETestPair(0x10000, vec![0x83, 0x01, 0x00, 0x00]),
|
||||
ETestPair(0xffffff, vec![0x83, 0xff, 0xff, 0xff]),
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_u64() {
|
||||
let tests = vec![
|
||||
ETestPair(0u64, vec![0x80u8]),
|
||||
ETestPair(0x1000000, vec![0x84, 0x01, 0x00, 0x00, 0x00]),
|
||||
ETestPair(0xFFFFFFFF, vec![0x84, 0xff, 0xff, 0xff, 0xff]),
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_u256() {
|
||||
let tests = vec![ETestPair(U256::from(0u64), vec![0x80u8]),
|
||||
ETestPair(U256::from(0x1000000u64), vec![0x84, 0x01, 0x00, 0x00, 0x00]),
|
||||
ETestPair(U256::from(0xffffffffu64),
|
||||
vec![0x84, 0xff, 0xff, 0xff, 0xff]),
|
||||
ETestPair(U256::from_str("8090a0b0c0d0e0f00910203040506077000000000000\
|
||||
000100000000000012f0")
|
||||
.unwrap(),
|
||||
vec![0xa0, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
|
||||
0x09, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x77, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x12, 0xf0])];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_str() {
|
||||
let tests = vec![ETestPair("cat", vec![0x83, b'c', b'a', b't']),
|
||||
ETestPair("dog", vec![0x83, b'd', b'o', b'g']),
|
||||
ETestPair("Marek", vec![0x85, b'M', b'a', b'r', b'e', b'k']),
|
||||
ETestPair("", vec![0x80]),
|
||||
ETestPair("Lorem ipsum dolor sit amet, consectetur adipisicing elit",
|
||||
vec![0xb8, 0x38, b'L', b'o', b'r', b'e', b'm', b' ', b'i',
|
||||
b'p', b's', b'u', b'm', b' ', b'd', b'o', b'l', b'o',
|
||||
b'r', b' ', b's', b'i', b't', b' ', b'a', b'm', b'e',
|
||||
b't', b',', b' ', b'c', b'o', b'n', b's', b'e', b'c',
|
||||
b't', b'e', b't', b'u', b'r', b' ', b'a', b'd', b'i',
|
||||
b'p', b'i', b's', b'i', b'c', b'i', b'n', b'g', b' ',
|
||||
b'e', b'l', b'i', b't'])];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_address() {
|
||||
use hash::*;
|
||||
|
||||
let tests = vec![
|
||||
ETestPair(Address::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap(),
|
||||
vec![0x94, 0xef, 0x2d, 0x6d, 0x19, 0x40, 0x84, 0xc2, 0xde,
|
||||
0x36, 0xe0, 0xda, 0xbf, 0xce, 0x45, 0xd0, 0x46,
|
||||
0xb3, 0x7d, 0x11, 0x06])
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
/// Vec<u8> (Bytes) is treated as a single value
|
||||
#[test]
|
||||
fn encode_vector_u8() {
|
||||
let tests = vec![
|
||||
ETestPair(vec![], vec![0x80]),
|
||||
ETestPair(vec![0u8], vec![0]),
|
||||
ETestPair(vec![0x15], vec![0x15]),
|
||||
ETestPair(vec![0x40, 0x00], vec![0x82, 0x40, 0x00]),
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_vector_u64() {
|
||||
let tests = vec![
|
||||
ETestPair(vec![], vec![0xc0]),
|
||||
ETestPair(vec![15u64], vec![0xc1, 0x0f]),
|
||||
ETestPair(vec![1, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
ETestPair(vec![0xffffffff, 1, 2, 3, 7, 0xff], vec![0xcb, 0x84, 0xff, 0xff, 0xff, 0xff, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_vector_str() {
|
||||
let tests = vec![ETestPair(vec!["cat", "dog"],
|
||||
vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'])];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_vector_of_vectors_str() {
|
||||
let tests = vec![ETestPair(vec![vec!["cat"]], vec![0xc5, 0xc4, 0x83, b'c', b'a', b't'])];
|
||||
run_encode_tests(tests);
|
||||
}
|
||||
|
||||
struct DTestPair<T>(T, Vec<u8>) where T: rlp::Decodable + fmt::Debug + cmp::Eq;
|
||||
|
||||
fn run_decode_tests<T>(tests: Vec<DTestPair<T>>) where T: rlp::Decodable + fmt::Debug + cmp::Eq {
|
||||
for t in &tests {
|
||||
let res: T = rlp::decode(&t.1);
|
||||
assert_eq!(res, t.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// Vec<u8> (Bytes) is treated as a single value
|
||||
#[test]
|
||||
fn decode_vector_u8() {
|
||||
let tests = vec![
|
||||
DTestPair(vec![], vec![0x80]),
|
||||
DTestPair(vec![0u8], vec![0]),
|
||||
DTestPair(vec![0x15], vec![0x15]),
|
||||
DTestPair(vec![0x40, 0x00], vec![0x82, 0x40, 0x00]),
|
||||
];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_u16() {
|
||||
let tests = vec![
|
||||
DTestPair(0u16, vec![0u8]),
|
||||
DTestPair(0x100, vec![0x82, 0x01, 0x00]),
|
||||
DTestPair(0xffff, vec![0x82, 0xff, 0xff]),
|
||||
];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_u32() {
|
||||
let tests = vec![
|
||||
DTestPair(0u32, vec![0u8]),
|
||||
DTestPair(0x10000, vec![0x83, 0x01, 0x00, 0x00]),
|
||||
DTestPair(0xffffff, vec![0x83, 0xff, 0xff, 0xff]),
|
||||
];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_u64() {
|
||||
let tests = vec![
|
||||
DTestPair(0u64, vec![0u8]),
|
||||
DTestPair(0x1000000, vec![0x84, 0x01, 0x00, 0x00, 0x00]),
|
||||
DTestPair(0xFFFFFFFF, vec![0x84, 0xff, 0xff, 0xff, 0xff]),
|
||||
];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_u256() {
|
||||
let tests = vec![DTestPair(U256::from(0u64), vec![0x80u8]),
|
||||
DTestPair(U256::from(0x1000000u64), vec![0x84, 0x01, 0x00, 0x00, 0x00]),
|
||||
DTestPair(U256::from(0xffffffffu64),
|
||||
vec![0x84, 0xff, 0xff, 0xff, 0xff]),
|
||||
DTestPair(U256::from_str("8090a0b0c0d0e0f00910203040506077000000000000\
|
||||
000100000000000012f0")
|
||||
.unwrap(),
|
||||
vec![0xa0, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
|
||||
0x09, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x77, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x12, 0xf0])];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_str() {
|
||||
let tests = vec![DTestPair("cat".to_string(), vec![0x83, b'c', b'a', b't']),
|
||||
DTestPair("dog".to_string(), vec![0x83, b'd', b'o', b'g']),
|
||||
DTestPair("Marek".to_string(),
|
||||
vec![0x85, b'M', b'a', b'r', b'e', b'k']),
|
||||
DTestPair("".to_string(), vec![0x80]),
|
||||
DTestPair("Lorem ipsum dolor sit amet, consectetur adipisicing elit"
|
||||
.to_string(),
|
||||
vec![0xb8, 0x38, b'L', b'o', b'r', b'e', b'm', b' ', b'i',
|
||||
b'p', b's', b'u', b'm', b' ', b'd', b'o', b'l', b'o',
|
||||
b'r', b' ', b's', b'i', b't', b' ', b'a', b'm', b'e',
|
||||
b't', b',', b' ', b'c', b'o', b'n', b's', b'e', b'c',
|
||||
b't', b'e', b't', b'u', b'r', b' ', b'a', b'd', b'i',
|
||||
b'p', b'i', b's', b'i', b'c', b'i', b'n', b'g', b' ',
|
||||
b'e', b'l', b'i', b't'])];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_address() {
|
||||
use hash::*;
|
||||
|
||||
let tests = vec![
|
||||
DTestPair(Address::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap(),
|
||||
vec![0x94, 0xef, 0x2d, 0x6d, 0x19, 0x40, 0x84, 0xc2, 0xde,
|
||||
0x36, 0xe0, 0xda, 0xbf, 0xce, 0x45, 0xd0, 0x46,
|
||||
0xb3, 0x7d, 0x11, 0x06])
|
||||
];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_vector_u64() {
|
||||
let tests = vec![
|
||||
DTestPair(vec![], vec![0xc0]),
|
||||
DTestPair(vec![15u64], vec![0xc1, 0x0f]),
|
||||
DTestPair(vec![1, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
DTestPair(vec![0xffffffff, 1, 2, 3, 7, 0xff], vec![0xcb, 0x84, 0xff, 0xff, 0xff, 0xff, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_vector_str() {
|
||||
let tests = vec![DTestPair(vec!["cat".to_string(), "dog".to_string()],
|
||||
vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'])];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decode_untrusted_vector_of_vectors_str() {
|
||||
let tests = vec![DTestPair(vec![vec!["cat".to_string()]],
|
||||
vec![0xc5, 0xc4, 0x83, b'c', b'a', b't'])];
|
||||
run_decode_tests(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rlp_json() {
|
||||
println!("Json rlp test: ");
|
||||
execute_tests_from_directory::<rlptest::RlpStreamTest, _>("json-tests/json/rlp/stream/*.json", &mut | file, input, output | {
|
||||
println!("file: {}", file);
|
||||
|
||||
let mut stream = RlpStream::new();
|
||||
for operation in input.into_iter() {
|
||||
match operation {
|
||||
rlptest::Operation::Append(ref v) => stream.append(v),
|
||||
rlptest::Operation::AppendList(len) => stream.append_list(len),
|
||||
rlptest::Operation::AppendRaw(ref raw, len) => stream.append_raw(raw, len),
|
||||
rlptest::Operation::AppendEmpty => stream.append_empty_data()
|
||||
};
|
||||
}
|
||||
|
||||
assert_eq!(stream.out(), output);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_decoding_array() {
|
||||
let v = vec![5u16, 2u16];
|
||||
let res = rlp::encode(&v);
|
||||
let arr: [u16; 2] = rlp::decode(&res);
|
||||
assert_eq!(arr[0], 5);
|
||||
assert_eq!(arr[1], 2);
|
||||
}
|
||||
290
src/rlp/traits.rs
Normal file
290
src/rlp/traits.rs
Normal file
@ -0,0 +1,290 @@
|
||||
use rlp::DecoderError;
|
||||
|
||||
pub trait Decoder: Sized {
|
||||
fn read_value<T, F>(&self, f: F) -> Result<T, DecoderError>
|
||||
where F: FnOnce(&[u8]) -> Result<T, DecoderError>;
|
||||
|
||||
fn as_list(&self) -> Result<Vec<Self>, DecoderError>;
|
||||
}
|
||||
|
||||
pub trait Decodable: Sized {
|
||||
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder;
|
||||
}
|
||||
|
||||
pub trait View<'a, 'view>: Sized {
|
||||
type Prototype;
|
||||
type PayloadInfo;
|
||||
type Data;
|
||||
type Item;
|
||||
type Iter;
|
||||
|
||||
/// Creates a new instance of `Rlp` reader
|
||||
fn new(bytes: &'a [u8]) -> Self;
|
||||
|
||||
/// The raw data of the RLP.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// let dog = rlp.at(1).raw();
|
||||
/// assert_eq!(dog, &[0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
/// ```
|
||||
fn raw(&'view self) -> &'a [u8];
|
||||
|
||||
/// Get the prototype of the RLP.
|
||||
fn prototype(&self) -> Self::Prototype;
|
||||
|
||||
fn payload_info(&self) -> Self::PayloadInfo;
|
||||
|
||||
fn data(&'view self) -> Self::Data;
|
||||
|
||||
/// Returns number of RLP items.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert_eq!(rlp.item_count(), 2);
|
||||
/// let view = rlp.at(1);
|
||||
/// assert_eq!(view.item_count(), 0);
|
||||
/// }
|
||||
/// ```
|
||||
fn item_count(&self) -> usize;
|
||||
|
||||
/// Returns the number of bytes in the data, or zero if it isn't data.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert_eq!(rlp.size(), 0);
|
||||
/// let view = rlp.at(1);
|
||||
/// assert_eq!(view.size(), 3);
|
||||
/// }
|
||||
/// ```
|
||||
fn size(&self) -> usize;
|
||||
|
||||
/// Get view onto RLP-slice at index.
|
||||
///
|
||||
/// Caches offset to given index, so access to successive
|
||||
/// slices is faster.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// let dog: String = rlp.at(1).as_val();
|
||||
/// assert_eq!(dog, "dog".to_string());
|
||||
/// }
|
||||
fn at(&'view self, index: usize) -> Self::Item;
|
||||
|
||||
/// No value
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert!(rlp.is_null());
|
||||
/// }
|
||||
/// ```
|
||||
fn is_null(&self) -> bool;
|
||||
|
||||
/// Contains a zero-length string or zero-length list.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc0];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert!(rlp.is_empty());
|
||||
/// }
|
||||
/// ```
|
||||
fn is_empty(&self) -> bool;
|
||||
|
||||
/// List value
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert!(rlp.is_list());
|
||||
/// }
|
||||
/// ```
|
||||
fn is_list(&self) -> bool;
|
||||
|
||||
/// String value
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert!(rlp.at(1).is_data());
|
||||
/// }
|
||||
/// ```
|
||||
fn is_data(&self) -> bool;
|
||||
|
||||
/// Int value
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc1, 0x10];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// assert_eq!(rlp.is_int(), false);
|
||||
/// assert_eq!(rlp.at(0).is_int(), true);
|
||||
/// }
|
||||
/// ```
|
||||
fn is_int(&self) -> bool;
|
||||
|
||||
/// Get iterator over rlp-slices
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
|
||||
/// let rlp = Rlp::new(&data);
|
||||
/// let strings: Vec<String> = rlp.iter().map(| i | i.as_val()).collect();
|
||||
/// }
|
||||
/// ```
|
||||
fn iter(&'view self) -> Self::Iter;
|
||||
|
||||
fn as_val<T>(&self) -> Result<T, DecoderError> where T: Decodable;
|
||||
|
||||
fn val_at<T>(&self, index: usize) -> Result<T, DecoderError> where T: Decodable;
|
||||
}
|
||||
|
||||
pub trait Encoder {
|
||||
fn emit_value(&mut self, bytes: &[u8]) -> ();
|
||||
fn emit_list<F>(&mut self, f: F) -> () where F: FnOnce(&mut Self) -> ();
|
||||
}
|
||||
|
||||
pub trait Encodable {
|
||||
fn encode<E>(&self, encoder: &mut E) -> () where E: Encoder;
|
||||
}
|
||||
|
||||
pub trait Stream: Sized {
|
||||
|
||||
/// Initializes instance of empty `Stream`.
|
||||
fn new() -> Self;
|
||||
|
||||
/// Initializes the `Stream` as a list.
|
||||
fn new_list(len: usize) -> Self;
|
||||
|
||||
/// Apends value to the end of stream, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append(&"cat").append(&"dog");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
/// ```
|
||||
fn append<'a, E>(&'a mut self, object: &E) -> &'a mut Self where E: Encodable;
|
||||
|
||||
/// Declare appending the list of given size, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append_list(2).append(&"cat").append(&"dog");
|
||||
/// stream.append(&"");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]);
|
||||
/// }
|
||||
/// ```
|
||||
fn append_list<'a>(&'a mut self, len: usize) -> &'a mut Self;
|
||||
|
||||
/// Apends null to the end of stream, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append_empty_data().append_empty_data();
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc2, 0x80, 0x80]);
|
||||
/// }
|
||||
/// ```
|
||||
fn append_empty_data<'a>(&'a mut self) -> &'a mut Self;
|
||||
|
||||
/// Appends raw (pre-serialised) RLP data. Use with caution. Chainable.
|
||||
fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut Self;
|
||||
|
||||
/// Clear the output stream so far.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(3);
|
||||
/// stream.append(&"cat");
|
||||
/// stream.clear();
|
||||
/// stream.append(&"dog");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
fn clear(&mut self);
|
||||
|
||||
/// Returns true if stream doesnt expect any more items.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use util::rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append(&"cat");
|
||||
/// assert_eq!(stream.is_finished(), false);
|
||||
/// stream.append(&"dog");
|
||||
/// assert_eq!(stream.is_finished(), true);
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
fn is_finished(&self) -> bool;
|
||||
|
||||
fn raw(&self) -> &[u8];
|
||||
|
||||
/// Streams out encoded bytes.
|
||||
///
|
||||
/// panic! if stream is not finished.
|
||||
fn out(self) -> Vec<u8>;
|
||||
}
|
||||
386
src/rlp/untrusted_rlp.rs
Normal file
386
src/rlp/untrusted_rlp.rs
Normal file
@ -0,0 +1,386 @@
|
||||
use std::cell::Cell;
|
||||
use bytes::{FromBytes};
|
||||
use rlp::{View, Decoder, Decodable, DecoderError};
|
||||
|
||||
/// rlp offset
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
struct OffsetCache {
|
||||
index: usize,
|
||||
offset: usize,
|
||||
}
|
||||
|
||||
impl OffsetCache {
|
||||
fn new(index: usize, offset: usize) -> OffsetCache {
|
||||
OffsetCache {
|
||||
index: index,
|
||||
offset: offset,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Prototype {
|
||||
Null,
|
||||
Data(usize),
|
||||
List(usize),
|
||||
}
|
||||
|
||||
/// Stores basic information about item
|
||||
pub struct PayloadInfo {
|
||||
pub header_len: usize,
|
||||
pub value_len: usize,
|
||||
}
|
||||
|
||||
impl PayloadInfo {
|
||||
fn new(header_len: usize, value_len: usize) -> PayloadInfo {
|
||||
PayloadInfo {
|
||||
header_len: header_len,
|
||||
value_len: value_len,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Data-oriented view onto rlp-slice.
|
||||
///
|
||||
/// This is immutable structere. No operations change it.
|
||||
///
|
||||
/// Should be used in places where, error handling is required,
|
||||
/// eg. on input
|
||||
#[derive(Debug)]
|
||||
pub struct UntrustedRlp<'a> {
|
||||
bytes: &'a [u8],
|
||||
cache: Cell<OffsetCache>,
|
||||
}
|
||||
|
||||
impl<'a> Clone for UntrustedRlp<'a> {
|
||||
fn clone(&self) -> UntrustedRlp<'a> {
|
||||
UntrustedRlp {
|
||||
bytes: self.bytes,
|
||||
cache: Cell::new(OffsetCache::new(usize::max_value(), 0))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view {
|
||||
type Prototype = Result<Prototype, DecoderError>;
|
||||
type PayloadInfo = Result<PayloadInfo, DecoderError>;
|
||||
type Data = Result<&'a [u8], DecoderError>;
|
||||
type Item = Result<UntrustedRlp<'a>, DecoderError>;
|
||||
type Iter = UntrustedRlpIterator<'a, 'view>;
|
||||
|
||||
//returns new instance of `UntrustedRlp`
|
||||
fn new(bytes: &'a [u8]) -> UntrustedRlp<'a> {
|
||||
UntrustedRlp {
|
||||
bytes: bytes,
|
||||
cache: Cell::new(OffsetCache::new(usize::max_value(), 0)),
|
||||
}
|
||||
}
|
||||
|
||||
fn raw(&'view self) -> &'a [u8] {
|
||||
self.bytes
|
||||
}
|
||||
|
||||
fn prototype(&self) -> Self::Prototype {
|
||||
// optimize? && return appropriate errors
|
||||
if self.is_data() {
|
||||
Ok(Prototype::Data(self.size()))
|
||||
} else if self.is_list() {
|
||||
Ok(Prototype::List(self.item_count()))
|
||||
} else {
|
||||
Ok(Prototype::Null)
|
||||
}
|
||||
}
|
||||
|
||||
fn payload_info(&self) -> Self::PayloadInfo {
|
||||
BasicDecoder::payload_info(self.bytes)
|
||||
}
|
||||
|
||||
fn data(&'view self) -> Self::Data {
|
||||
let pi = try!(BasicDecoder::payload_info(self.bytes));
|
||||
Ok(&self.bytes[pi.header_len..(pi.header_len + pi.value_len)])
|
||||
}
|
||||
|
||||
fn item_count(&self) -> usize {
|
||||
match self.is_list() {
|
||||
true => self.iter().count(),
|
||||
false => 0
|
||||
}
|
||||
}
|
||||
|
||||
fn size(&self) -> usize {
|
||||
match self.is_data() {
|
||||
// we can safely unwrap (?) cause its data
|
||||
true => BasicDecoder::payload_info(self.bytes).unwrap().value_len,
|
||||
false => 0
|
||||
}
|
||||
}
|
||||
|
||||
fn at(&'view self, index: usize) -> Self::Item {
|
||||
if !self.is_list() {
|
||||
return Err(DecoderError::RlpExpectedToBeList);
|
||||
}
|
||||
|
||||
// move to cached position if it's index is less or equal to
|
||||
// current search index, otherwise move to beginning of list
|
||||
let c = self.cache.get();
|
||||
let (mut bytes, to_skip) = match c.index <= index {
|
||||
true => (try!(UntrustedRlp::consume(self.bytes, c.offset)), index - c.index),
|
||||
false => (try!(self.consume_list_prefix()), index),
|
||||
};
|
||||
|
||||
// skip up to x items
|
||||
bytes = try!(UntrustedRlp::consume_items(bytes, to_skip));
|
||||
|
||||
// update the cache
|
||||
self.cache.set(OffsetCache::new(index, self.bytes.len() - bytes.len()));
|
||||
|
||||
// construct new rlp
|
||||
let found = try!(BasicDecoder::payload_info(bytes));
|
||||
Ok(UntrustedRlp::new(&bytes[0..found.header_len + found.value_len]))
|
||||
}
|
||||
|
||||
fn is_null(&self) -> bool {
|
||||
self.bytes.len() == 0
|
||||
}
|
||||
|
||||
fn is_empty(&self) -> bool {
|
||||
!self.is_null() && (self.bytes[0] == 0xc0 || self.bytes[0] == 0x80)
|
||||
}
|
||||
|
||||
fn is_list(&self) -> bool {
|
||||
!self.is_null() && self.bytes[0] >= 0xc0
|
||||
}
|
||||
|
||||
fn is_data(&self) -> bool {
|
||||
!self.is_null() && self.bytes[0] < 0xc0
|
||||
}
|
||||
|
||||
fn is_int(&self) -> bool {
|
||||
if self.is_null() {
|
||||
return false;
|
||||
}
|
||||
|
||||
match self.bytes[0] {
|
||||
0...0x80 => true,
|
||||
0x81...0xb7 => self.bytes[1] != 0,
|
||||
b @ 0xb8...0xbf => self.bytes[1 + b as usize - 0xb7] != 0,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
fn iter(&'view self) -> Self::Iter {
|
||||
self.into_iter()
|
||||
}
|
||||
|
||||
fn as_val<T>(&self) -> Result<T, DecoderError> where T: Decodable {
|
||||
// optimize, so it doesn't use clone (although This clone is cheap)
|
||||
T::decode(&BasicDecoder::new(self.clone()))
|
||||
}
|
||||
|
||||
fn val_at<T>(&self, index: usize) -> Result<T, DecoderError> where T: Decodable {
|
||||
self.at(index).unwrap().as_val()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> UntrustedRlp<'a> {
|
||||
/// consumes first found prefix
|
||||
fn consume_list_prefix(&self) -> Result<&'a [u8], DecoderError> {
|
||||
let item = try!(BasicDecoder::payload_info(self.bytes));
|
||||
let bytes = try!(UntrustedRlp::consume(self.bytes, item.header_len));
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
/// consumes fixed number of items
|
||||
fn consume_items(bytes: &'a [u8], items: usize) -> Result<&'a [u8], DecoderError> {
|
||||
let mut result = bytes;
|
||||
for _ in 0..items {
|
||||
let i = try!(BasicDecoder::payload_info(result));
|
||||
result = try!(UntrustedRlp::consume(result, (i.header_len + i.value_len)));
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
|
||||
/// consumes slice prefix of length `len`
|
||||
fn consume(bytes: &'a [u8], len: usize) -> Result<&'a [u8], DecoderError> {
|
||||
match bytes.len() >= len {
|
||||
true => Ok(&bytes[len..]),
|
||||
false => Err(DecoderError::RlpIsTooShort),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Iterator over rlp-slice list elements.
|
||||
pub struct UntrustedRlpIterator<'a, 'view> where 'a: 'view {
|
||||
rlp: &'view UntrustedRlp<'a>,
|
||||
index: usize,
|
||||
}
|
||||
|
||||
impl<'a, 'view> IntoIterator for &'view UntrustedRlp<'a> where 'a: 'view {
|
||||
type Item = UntrustedRlp<'a>;
|
||||
type IntoIter = UntrustedRlpIterator<'a, 'view>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
UntrustedRlpIterator {
|
||||
rlp: self,
|
||||
index: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'view> Iterator for UntrustedRlpIterator<'a, 'view> {
|
||||
type Item = UntrustedRlp<'a>;
|
||||
|
||||
fn next(&mut self) -> Option<UntrustedRlp<'a>> {
|
||||
let index = self.index;
|
||||
let result = self.rlp.at(index).ok();
|
||||
self.index += 1;
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
struct BasicDecoder<'a> {
|
||||
rlp: UntrustedRlp<'a>
|
||||
}
|
||||
|
||||
impl<'a> BasicDecoder<'a> {
|
||||
pub fn new(rlp: UntrustedRlp<'a>) -> BasicDecoder<'a> {
|
||||
BasicDecoder {
|
||||
rlp: rlp
|
||||
}
|
||||
}
|
||||
|
||||
/// Return first item info
|
||||
fn payload_info(bytes: &[u8]) -> Result<PayloadInfo, DecoderError> {
|
||||
let item = match bytes.first().map(|&x| x) {
|
||||
None => return Err(DecoderError::RlpIsTooShort),
|
||||
Some(0...0x7f) => PayloadInfo::new(0, 1),
|
||||
Some(l @ 0x80...0xb7) => PayloadInfo::new(1, l as usize - 0x80),
|
||||
Some(l @ 0xb8...0xbf) => {
|
||||
let len_of_len = l as usize - 0xb7;
|
||||
let header_len = 1 + len_of_len;
|
||||
let value_len = try!(usize::from_bytes(&bytes[1..header_len]));
|
||||
PayloadInfo::new(header_len, value_len)
|
||||
}
|
||||
Some(l @ 0xc0...0xf7) => PayloadInfo::new(1, l as usize - 0xc0),
|
||||
Some(l @ 0xf8...0xff) => {
|
||||
let len_of_len = l as usize - 0xf7;
|
||||
let header_len = 1 + len_of_len;
|
||||
let value_len = try!(usize::from_bytes(&bytes[1..header_len]));
|
||||
PayloadInfo::new(header_len, value_len)
|
||||
},
|
||||
// we cant reach this place, but rust requires _ to be implemented
|
||||
_ => { unreachable!(); }
|
||||
};
|
||||
|
||||
match item.header_len + item.value_len <= bytes.len() {
|
||||
true => Ok(item),
|
||||
false => Err(DecoderError::RlpIsTooShort),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Decoder for BasicDecoder<'a> {
|
||||
fn read_value<T, F>(&self, f: F) -> Result<T, DecoderError>
|
||||
where F: FnOnce(&[u8]) -> Result<T, DecoderError> {
|
||||
|
||||
let bytes = self.rlp.raw();
|
||||
|
||||
match bytes.first().map(|&x| x) {
|
||||
// rlp is too short
|
||||
None => Err(DecoderError::RlpIsTooShort),
|
||||
// single byt value
|
||||
Some(l @ 0...0x7f) => Ok(try!(f(&[l]))),
|
||||
// 0-55 bytes
|
||||
Some(l @ 0x80...0xb7) => Ok(try!(f(&bytes[1..(1 + l as usize - 0x80)]))),
|
||||
// longer than 55 bytes
|
||||
Some(l @ 0xb8...0xbf) => {
|
||||
let len_of_len = l as usize - 0xb7;
|
||||
let begin_of_value = 1 as usize + len_of_len;
|
||||
let len = try!(usize::from_bytes(&bytes[1..begin_of_value]));
|
||||
Ok(try!(f(&bytes[begin_of_value..begin_of_value + len])))
|
||||
}
|
||||
// we are reading value, not a list!
|
||||
_ => Err(DecoderError::RlpExpectedToBeData)
|
||||
}
|
||||
}
|
||||
|
||||
fn as_list(&self) -> Result<Vec<Self>, DecoderError> {
|
||||
let v: Vec<BasicDecoder<'a>> = self.rlp.iter()
|
||||
.map(| i | BasicDecoder::new(i))
|
||||
.collect();
|
||||
Ok(v)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Decodable for T where T: FromBytes {
|
||||
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
|
||||
decoder.read_value(| bytes | {
|
||||
Ok(try!(T::from_bytes(bytes)))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Decodable for Vec<T> where T: Decodable {
|
||||
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
|
||||
let decoders = try!(decoder.as_list());
|
||||
decoders.iter().map(|d| T::decode(d)).collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl Decodable for Vec<u8> {
|
||||
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
|
||||
decoder.read_value(| bytes | {
|
||||
let mut res = vec![];
|
||||
res.extend(bytes);
|
||||
Ok(res)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Decodable for Option<T> where T: Decodable {
|
||||
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
|
||||
decoder.read_value(| bytes | {
|
||||
let res = match bytes.len() {
|
||||
0 => None,
|
||||
_ => Some(try!(T::decode(decoder)))
|
||||
};
|
||||
Ok(res)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_array_decodable {
|
||||
($index_type:ty, $len:expr ) => (
|
||||
impl<T> Decodable for [T; $len] where T: Decodable {
|
||||
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
|
||||
let decoders = try!(decoder.as_list());
|
||||
|
||||
let mut result: [T; $len] = unsafe { ::std::mem::uninitialized() };
|
||||
if decoders.len() != $len {
|
||||
return Err(DecoderError::RlpIncorrectListLen);
|
||||
}
|
||||
|
||||
for i in 0..decoders.len() {
|
||||
result[i] = try!(T::decode(&decoders[i]));
|
||||
}
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
macro_rules! impl_array_decodable_recursive {
|
||||
($index_type:ty, ) => ();
|
||||
($index_type:ty, $len:expr, $($more:expr,)*) => (
|
||||
impl_array_decodable!($index_type, $len);
|
||||
impl_array_decodable_recursive!($index_type, $($more,)*);
|
||||
);
|
||||
}
|
||||
|
||||
impl_array_decodable_recursive!(
|
||||
u8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 40, 48, 56, 64, 72, 96, 128, 160, 192, 224,
|
||||
);
|
||||
14
src/sha3.rs
14
src/sha3.rs
@ -1,8 +1,22 @@
|
||||
//! Wrapper around tiny-keccak crate.
|
||||
|
||||
use std::mem::uninitialized;
|
||||
use tiny_keccak::Keccak;
|
||||
use bytes::BytesConvertable;
|
||||
use hash::{FixedHash, H256};
|
||||
|
||||
/// Types implementing this trait are sha3able.
|
||||
///
|
||||
/// ```
|
||||
/// extern crate ethcore_util as util;
|
||||
/// use std::str::FromStr;
|
||||
/// use util::sha3::*;
|
||||
/// use util::hash::*;
|
||||
///
|
||||
/// fn main() {
|
||||
/// assert_eq!([0u8; 0].sha3(), H256::from_str("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").unwrap());
|
||||
/// }
|
||||
/// ```
|
||||
pub trait Hashable {
|
||||
fn sha3(&self) -> H256;
|
||||
fn sha3_into(&self, dest: &mut [u8]);
|
||||
|
||||
67
src/squeeze.rs
Normal file
67
src/squeeze.rs
Normal file
@ -0,0 +1,67 @@
|
||||
//! Helper module that should be used to randomly squeeze
|
||||
//! caches to a given size in bytes
|
||||
//!
|
||||
//! ```
|
||||
//! extern crate heapsize;
|
||||
//! extern crate ethcore_util as util;
|
||||
//! use std::collections::HashMap;
|
||||
//! use std::mem::size_of;
|
||||
//! use heapsize::HeapSizeOf;
|
||||
//! use util::squeeze::Squeeze;
|
||||
//!
|
||||
//! fn main() {
|
||||
//! let initial_size = 60;
|
||||
//! let mut map: HashMap<u8, u8> = HashMap::with_capacity(initial_size);
|
||||
//! assert!(map.capacity() >= initial_size);
|
||||
//! for i in 0..initial_size {
|
||||
//! map.insert(i as u8, i as u8);
|
||||
//! }
|
||||
//!
|
||||
//! assert_eq!(map.heap_size_of_children(), map.capacity() * 2 * size_of::<u8>());
|
||||
//! assert_eq!(map.len(), initial_size);
|
||||
//! let initial_heap_size = map.heap_size_of_children();
|
||||
//!
|
||||
//! // squeeze it to size of key and value
|
||||
//! map.squeeze(2 * size_of::<u8>());
|
||||
//! assert_eq!(map.len(), 1);
|
||||
//!
|
||||
//! // its likely that heap size was reduced, but we can't be 100% sure
|
||||
//! assert!(initial_heap_size >= map.heap_size_of_children());
|
||||
//! }
|
||||
//! ```
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::hash::Hash;
|
||||
use heapsize::HeapSizeOf;
|
||||
|
||||
/// Should be used to squeeze collections to certain size in bytes
|
||||
pub trait Squeeze {
|
||||
fn squeeze(&mut self, size: usize);
|
||||
}
|
||||
|
||||
impl<K, T> Squeeze for HashMap<K, T> where K: Eq + Hash + Clone + HeapSizeOf, T: HeapSizeOf {
|
||||
fn squeeze(&mut self, size: usize) {
|
||||
if self.len() == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
let size_of_entry = self.heap_size_of_children() / self.capacity();
|
||||
let all_entries = size_of_entry * self.len();
|
||||
let mut shrinked_size = all_entries;
|
||||
|
||||
while self.len() > 0 && shrinked_size > size {
|
||||
// could be optimized
|
||||
let key = self.keys().next().unwrap().clone();
|
||||
self.remove(&key);
|
||||
shrinked_size -= size_of_entry;
|
||||
}
|
||||
|
||||
self.shrink_to_fit();
|
||||
|
||||
// if we squeezed something, but not enough, squeeze again
|
||||
if all_entries != shrinked_size && self.heap_size_of_children() > size {
|
||||
self.squeeze(size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
833
src/trie.rs
833
src/trie.rs
File diff suppressed because it is too large
Load Diff
@ -1,4 +1,4 @@
|
||||
//! Generete trie root.
|
||||
//! Generetes trie root.
|
||||
//!
|
||||
//! This module should be used to generate trie root hash.
|
||||
|
||||
@ -7,10 +7,9 @@ use std::cmp;
|
||||
use hash::*;
|
||||
use sha3::*;
|
||||
use rlp;
|
||||
use rlp::RlpStream;
|
||||
use rlp::{RlpStream, Stream};
|
||||
use vector::SharedPrefix;
|
||||
|
||||
// todo: verify if example for ordered_trie_root is valid
|
||||
/// Generates a trie root hash for a vector of values
|
||||
///
|
||||
/// ```rust
|
||||
|
||||
1034
src/uint.rs
1034
src/uint.rs
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user