Merge branch 'master' of github.com:gavofyork/ethcore-util into network

Conflicts:
	src/lib.rs
	src/rlp.rs
	src/triehash.rs

Cargo.toml

@@ -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" }

Makefile

@@ -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)))

benches/rlp.rs

@@ -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 _v0: Vec<u16> = rlp.val_at(0);
-		let _v1: Vec<Vec<u16>> = Decodable::decode(&rlp.at(1));
+		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 _v2a: Vec<u16> = nested_rlp.val_at(0);
-		let _v2b: Vec<Vec<u16>> = Decodable::decode(&nested_rlp.at(1));
+		let _v2b: Vec<Vec<u16>> = nested_rlp.val_at(1);
 	});
 }
 

benches/trie.rs

@@ -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()
+		}
+	})
+}

src/chainfilter.rs

@@ -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 {
+		// eg. if levels == 3, index_size = 16
-			filter.level_sizes.push(pow(index_size, i as usize));
+		// 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
 	}

src/error.rs

@@ -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),

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 {
+				&self.0
-					::std::slice::from_raw_parts(self.0.as_ptr(), $size)
-				}
 			}
 		}
 		impl DerefMut for $from {
+
 			#[inline]
 			fn deref_mut(&mut self) -> &mut [u8] {
-				unsafe {
+				&mut self.0
-					::std::slice::from_raw_parts_mut(self.0.as_mut_ptr(), $size)
-				}
 			}
 		}
 
@@ -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);

src/hashdb.rs

@@ -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.

src/heapsizeof.rs

@@ -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);

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::*;
-

src/macros.rs

@@ -1,11 +0,0 @@
-macro_rules! map(
-    { $($key:expr => $value:expr),+ } => {
-        {
-            let mut m = ::std::collections::HashMap::new();
-            $(
-                m.insert($key, $value);
-            )+
-            m
-        }
-     };
-);

src/memorydb.rs

@@ -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> {
+	fn keys(&self) -> HashMap<H256, i32> {
-		self.data.iter().filter_map(|(k, v)| if v.1 > 0 {Some((k.clone(), v.1 as u32))} else {None} ).collect::<HashMap<H256, u32>>()
+		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 {

src/overlaydb.rs

@@ -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> {
+	fn keys(&self) -> HashMap<H256, i32> {
-		let mut ret: HashMap<H256, u32> = HashMap::new();
+		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() {
+		for (key, refs) in self.overlay.keys().into_iter() {
-			let refs = *ret.get(&key).unwrap_or(&0u32) as i32 + refs as i32;
+			let refs = *ret.get(&key).unwrap_or(&0) + refs;
-			ret.insert(key, refs as u32);
+			ret.insert(key, refs);
 		}
 		ret
 	}

src/rlp/errors.rs

@@ -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)
+	}
+}

src/rlp/mod.rs

@@ -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()
+}

src/rlp/rlp.rs

@@ -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
+	}
+}

src/rlp/rlpstream.rs

@@ -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(&[])
+		}
+	}
+}

src/rlp/tests.rs

@@ -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);
+}

src/rlp/traits.rs

@@ -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>;
+}

src/rlp/untrusted_rlp.rs

@@ -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,
+);

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]);

src/squeeze.rs

@@ -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);
+		}
+	}
+}
+

src/triehash.rs

@@ -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