grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

in pro...

Browse Source
This commit is contained in:
debris 2015-11-29 18:44:29 +01:00
parent 7e58f12712
commit f7ec667852
4 changed files with 391 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/bytes.rs
View File

@ -104,27 +104,27 @@ impl ToBytes for String {
fn to_bytes_len(&self) -> usize { self.len() } fn to_bytes_len(&self) -> usize { self.len() }
} }
impl ToBytes for u8 { //impl ToBytes for u8 {
fn to_bytes(&self) -> Vec<u8> { //fn to_bytes(&self) -> Vec<u8> {
match *self { //match *self {
0 => vec![], //0 => vec![],
_ => vec![*self] //_ => vec![*self]
} //}
} //}
fn to_bytes_len(&self) -> usize { //fn to_bytes_len(&self) -> usize {
match *self { //match *self {
0 => 0, //0 => 0,
_ => 1 //_ => 1
} //}
} //}
fn first_byte(&self) -> Option<u8> { //fn first_byte(&self) -> Option<u8> {
match *self { //match *self {
0 => None, //0 => None,
_ => Some(*self) //_ => Some(*self)
} //}
} //}
} //}
impl ToBytes for u64 { impl ToBytes for u64 {
fn to_bytes(&self) -> Vec<u8> { fn to_bytes(&self) -> Vec<u8> {
@ -223,14 +223,14 @@ impl FromBytes for String {
} }
} }
impl FromBytes for u8 { //impl FromBytes for u8 {
fn from_bytes(bytes: &[u8]) -> FromBytesResult<u8> { //fn from_bytes(bytes: &[u8]) -> FromBytesResult<u8> {
match bytes.len() { //match bytes.len() {
0 => Ok(0), //0 => Ok(0),
_ => Ok(bytes[0]) //_ => Ok(bytes[0])
} //}
} //}
} //}
impl FromBytes for u64 { impl FromBytes for u64 {
fn from_bytes(bytes: &[u8]) -> FromBytesResult<u64> { fn from_bytes(bytes: &[u8]) -> FromBytesResult<u64> {

90
src/rlp.rs
View File

@ -478,7 +478,7 @@ impl RlpStream {
} }
/// Appends raw (pre-serialised) RLP data. Use with caution. Chainable. /// Appends raw (pre-serialised) RLP data. Use with caution. Chainable.
pub fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a RlpStream { pub fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut RlpStream {
// push raw items // push raw items
self.encoder.bytes.extend(bytes); self.encoder.bytes.extend(bytes);
@ -745,19 +745,19 @@ mod tests {
} }
} }
#[test] //#[test]
fn encode_u8() { //fn encode_u8() {
let tests = vec![ //let tests = vec![
ETestPair(0u8, vec![0x80u8]), //ETestPair(0u8, vec![0x80u8]),
ETestPair(15, vec![15]), //ETestPair(15, vec![15]),
ETestPair(55, vec![55]), //ETestPair(55, vec![55]),
ETestPair(56, vec![56]), //ETestPair(56, vec![56]),
ETestPair(0x7f, vec![0x7f]), //ETestPair(0x7f, vec![0x7f]),
ETestPair(0x80, vec![0x81, 0x80]), //ETestPair(0x80, vec![0x81, 0x80]),
ETestPair(0xff, vec![0x81, 0xff]), //ETestPair(0xff, vec![0x81, 0xff]),
]; //];
run_encode_tests(tests); //run_encode_tests(tests);
} //}
#[test] #[test]
fn encode_u16() { fn encode_u16() {
@ -835,15 +835,15 @@ mod tests {
run_encode_tests(tests); run_encode_tests(tests);
} }
#[test] //#[test]
fn encode_vector_u8() { //fn encode_vector_u8() {
let tests = vec![ //let tests = vec![
ETestPair(vec![], vec![0xc0]), //ETestPair(vec![], vec![0xc0]),
ETestPair(vec![15u8], vec![0xc1, 0x0f]), //ETestPair(vec![15u8], vec![0xc1, 0x0f]),
ETestPair(vec![1, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]), //ETestPair(vec![1, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]),
]; //];
run_encode_tests(tests); //run_encode_tests(tests);
} //}
#[test] #[test]
fn encode_vector_u64() { fn encode_vector_u64() {
@ -899,19 +899,19 @@ mod tests {
} }
} }
#[test] //#[test]
fn decode_untrusted_u8() { //fn decode_untrusted_u8() {
let tests = vec![ //let tests = vec![
DTestPair(0u8, vec![0u8]), //DTestPair(0u8, vec![0u8]),
DTestPair(15, vec![15]), //DTestPair(15, vec![15]),
DTestPair(55, vec![55]), //DTestPair(55, vec![55]),
DTestPair(56, vec![56]), //DTestPair(56, vec![56]),
DTestPair(0x7f, vec![0x7f]), //DTestPair(0x7f, vec![0x7f]),
DTestPair(0x80, vec![0x81, 0x80]), //DTestPair(0x80, vec![0x81, 0x80]),
DTestPair(0xff, vec![0x81, 0xff]), //DTestPair(0xff, vec![0x81, 0xff]),
]; //];
run_decode_untrusted_tests(tests); //run_decode_untrusted_tests(tests);
} //}
#[test] #[test]
fn decode_untrusted_u16() { fn decode_untrusted_u16() {
@ -991,15 +991,15 @@ mod tests {
run_decode_untrusted_tests(tests); run_decode_untrusted_tests(tests);
} }
#[test] //#[test]
fn decode_untrusted_vector_u8() { //fn decode_untrusted_vector_u8() {
let tests = vec![ //let tests = vec![
DTestPair(vec![] as Vec<u8>, vec![0xc0]), //DTestPair(vec![] as Vec<u8>, vec![0xc0]),
DTestPair(vec![15u8], vec![0xc1, 0x0f]), //DTestPair(vec![15u8], vec![0xc1, 0x0f]),
DTestPair(vec![1u8, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]), //DTestPair(vec![1u8, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]),
]; //];
run_decode_untrusted_tests(tests); //run_decode_untrusted_tests(tests);
} //}
#[test] #[test]
fn decode_untrusted_vector_u64() { fn decode_untrusted_vector_u64() {

435
src/triehash.rs
View File

@ -1,171 +1,300 @@
//! Generete trie root //! Generete trie root
use std::collections::BTreeMap; //use std::collections::BTreeMap;
use std::cmp; //use std::cmp;
use hash::*; //use hash::*;
use sha3::*; //use sha3::*;
use rlp; //use rlp;
use rlp::RlpStream; //use rlp::RlpStream;
//use vector::SharedPrefix;
/// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1. ///// Hex-prefix Notation. First nibble has flags: oddness = 2^0 & termination = 2^1.
/// /////
/// The "termination marker" and "leaf-node" specifier are completely equivalent. ///// The "termination marker" and "leaf-node" specifier are completely equivalent.
/// /////
/// Input values are in range `[0, 0xf]`. ///// Input values are in range `[0, 0xf]`.
/// /////
/// ```markdown ///// ```markdown
/// [0,0,1,2,3,4,5] 0x10012345 // 7 > 4 ///// [0,0,1,2,3,4,5] 0x10012345 // 7 > 4
/// [0,1,2,3,4,5] 0x00012345 // 6 > 4 ///// [0,1,2,3,4,5] 0x00012345 // 6 > 4
/// [1,2,3,4,5] 0x112345 // 5 > 3 ///// [1,2,3,4,5] 0x112345 // 5 > 3
/// [0,0,1,2,3,4] 0x00001234 // 6 > 3 ///// [0,0,1,2,3,4] 0x00001234 // 6 > 3
/// [0,1,2,3,4] 0x101234 // 5 > 3 ///// [0,1,2,3,4] 0x101234 // 5 > 3
/// [1,2,3,4] 0x001234 // 4 > 3 ///// [1,2,3,4] 0x001234 // 4 > 3
/// [0,0,1,2,3,4,5,T] 0x30012345 // 7 > 4 ///// [0,0,1,2,3,4,5,T] 0x30012345 // 7 > 4
/// [0,0,1,2,3,4,T] 0x20001234 // 6 > 4 ///// [0,0,1,2,3,4,T] 0x20001234 // 6 > 4
/// [0,1,2,3,4,5,T] 0x20012345 // 6 > 4 ///// [0,1,2,3,4,5,T] 0x20012345 // 6 > 4
/// [1,2,3,4,5,T] 0x312345 // 5 > 3 ///// [1,2,3,4,5,T] 0x312345 // 5 > 3
/// [1,2,3,4,T] 0x201234 // 4 > 3 ///// [1,2,3,4,T] 0x201234 // 4 > 3
/// ``` ///// ```
/// /////
/// ```rust ///// ```rust
/// extern crate ethcore_util as util; ///// extern crate ethcore_util as util;
/// use util::triehash::*; ///// use util::triehash::*;
/// /////
/// fn main() { ///// fn main() {
/// let v = vec![0, 0, 1, 2, 3, 4, 5]; ///// let v = vec![0, 0, 1, 2, 3, 4, 5];
/// let e = vec![0x10, 0x01, 0x23, 0x45]; ///// let e = vec![0x10, 0x01, 0x23, 0x45];
/// let h = hex_prefix_encode(&v, false); ///// let h = hex_prefix_encode(&v, false);
/// assert_eq!(h, e); ///// assert_eq!(h, e);
/// /////
/// let v = vec![0, 1, 2, 3, 4, 5]; ///// let v = vec![0, 1, 2, 3, 4, 5];
/// let e = vec![0x00, 0x01, 0x23, 0x45]; ///// let e = vec![0x00, 0x01, 0x23, 0x45];
/// let h = hex_prefix_encode(&v, false); ///// let h = hex_prefix_encode(&v, false);
/// assert_eq!(h, e); ///// assert_eq!(h, e);
/// /////
/// let v = vec![0, 1, 2, 3, 4, 5]; ///// let v = vec![0, 1, 2, 3, 4, 5];
/// let e = vec![0x20, 0x01, 0x23, 0x45]; ///// let e = vec![0x20, 0x01, 0x23, 0x45];
/// let h = hex_prefix_encode(&v, true); ///// let h = hex_prefix_encode(&v, true);
/// assert_eq!(h, e); ///// assert_eq!(h, e);
/// /////
/// let v = vec![1, 2, 3, 4, 5]; ///// let v = vec![1, 2, 3, 4, 5];
/// let e = vec![0x31, 0x23, 0x45]; ///// let e = vec![0x31, 0x23, 0x45];
/// let h = hex_prefix_encode(&v, true); ///// let h = hex_prefix_encode(&v, true);
/// assert_eq!(h, e); ///// assert_eq!(h, e);
/// /////
/// let v = vec![1, 2, 3, 4]; ///// let v = vec![1, 2, 3, 4];
/// let e = vec![0x00, 0x12, 0x34]; ///// let e = vec![0x00, 0x12, 0x34];
/// let h = hex_prefix_encode(&v, false); ///// let h = hex_prefix_encode(&v, false);
/// assert_eq!(h, e); ///// assert_eq!(h, e);
/// } /////
/// ``` ///// let v = vec![4, 1];
/// ///// let e = vec![0x20, 0x41];
pub fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec<u8> { ///// let h = hex_prefix_encode(&v, true);
let inlen = nibbles.len(); ///// assert_eq!(h, e);
let oddness_factor = inlen % 2; ///// }
// next even number divided by two ///// ```
let reslen = (inlen + 2) >> 1; /////
let mut res = vec![]; //pub fn hex_prefix_encode(nibbles: &[u8], leaf: bool) -> Vec<u8> {
res.reserve(reslen); //let inlen = nibbles.len();
//let oddness_factor = inlen % 2;
//// next even number divided by two
//let reslen = (inlen + 2) >> 1;
//let mut res = vec![];
//res.reserve(reslen);
let first_byte = { //let first_byte = {
let mut bits = ((inlen as u8 & 1) + (2 * leaf as u8)) << 4; //let mut bits = ((inlen as u8 & 1) + (2 * leaf as u8)) << 4;
if oddness_factor == 1 { //if oddness_factor == 1 {
bits += nibbles[0]; //bits += nibbles[0];
} //}
bits //bits
}; //};
res.push(first_byte); //res.push(first_byte);
let mut offset = oddness_factor; //let mut offset = oddness_factor;
while offset < inlen { //while offset < inlen {
let byte = (nibbles[offset] << 4) + nibbles[offset + 1]; //let byte = (nibbles[offset] << 4) + nibbles[offset + 1];
res.push(byte); //res.push(byte);
offset += 2; //offset += 2;
} //}
res //res
} //}
/// Converts slice of bytes to nibbles. ///// Converts slice of bytes to nibbles.
/// /////
/// ```rust ///// ```rust
/// extern crate ethcore_util as util; ///// extern crate ethcore_util as util;
/// use util::triehash::*; ///// use util::triehash::*;
/// /////
/// fn main () { ///// fn main () {
/// let v = vec![0x31, 0x23, 0x45]; ///// let v = vec![0x31, 0x23, 0x45];
/// let e = vec![3, 1, 2, 3, 4, 5]; ///// let e = vec![3, 1, 2, 3, 4, 5];
/// assert_eq!(as_nibbles(&v), e); ///// assert_eq!(as_nibbles(&v), e);
/// } /////
/// ``` ///// // A => 65 => 0x41 => [4, 1]
pub fn as_nibbles(bytes: &[u8]) -> Vec<u8> { ///// let v: Vec<u8> = From::from("A");
let mut res = vec![]; ///// let e = vec![4, 1];
res.reserve(bytes.len() * 2); ///// assert_eq!(as_nibbles(&v), e);
for i in 0..bytes.len() { ///// }
res.push(bytes[i] >> 4); ///// ```
res.push((bytes[i] << 4) >> 4); //pub fn as_nibbles(bytes: &[u8]) -> Vec<u8> {
} //let mut res = vec![];
res //res.reserve(bytes.len() * 2);
} //for i in 0..bytes.len() {
//res.push(bytes[i] >> 4);
//res.push((bytes[i] << 4) >> 4);
//}
//res
//}
struct NibblePair { //#[derive(Debug)]
nibble: Vec<u8>, //pub struct NibblePair {
data: Vec<u8> //nibble: Vec<u8>,
} //data: Vec<u8>
//}
pub fn ordered_trie_root(data: Vec<Vec<u8>>) -> H256 { //impl NibblePair {
let vec: Vec<NibblePair> = data //pub fn new(nibble: Vec<u8>, data: Vec<u8>) -> NibblePair {
// first put elements into btree to sort them by nibbles //NibblePair {
// optimize it later //nibble: nibble,
.into_iter() //data: data
.fold(BTreeMap::new(), | mut acc, vec | { //}
let len = acc.len(); //}
acc.insert(as_nibbles(&rlp::encode(&len)), vec);
acc
})
// then move them to a vector
.into_iter()
.map(|(k, v)| NibblePair { nibble: k, data: v } )
.collect();
let out = match vec.len() { //pub fn new_raw(to_nibble: Vec<u8>, data: Vec<u8>) -> NibblePair {
0 => rlp::encode(&""), //NibblePair::new(as_nibbles(&to_nibble), data)
_ => { //}
let mut stream = RlpStream::new(); //}
hash256rlp(&vec, 0, &mut stream);
stream.out().unwrap() //pub fn ordered_trie_root(data: Vec<Vec<u8>>) -> H256 {
} //let vec: Vec<NibblePair> = data
}; //// first put elements into btree to sort them by nibbles
//// optimize it later
//.into_iter()
//.fold(BTreeMap::new(), | mut acc, vec | {
//let len = acc.len();
//acc.insert(as_nibbles(&rlp::encode(&len)), vec);
//acc
//})
//// then move them to a vector
//.into_iter()
//.map(|(k, v)| NibblePair::new(k, v) )
//.collect();
//hash256(&vec)
//}
//pub fn hash256(vec: &[NibblePair]) -> H256 {
//let out = match vec.len() {
//0 => rlp::encode(&""),
//_ => {
//let mut stream = RlpStream::new();
//hash256rlp(&vec, 0, &mut stream);
//stream.out().unwrap()
//}
//};
out.sha3() //println!("out: {:?}", out);
} //out.sha3()
//}
fn shared_prefix_length<T>(v1: &[T], v2: &[T]) -> usize where T: Eq { //fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
let len = cmp::min(v1.len(), v2.len()); //match vec.len() {
(0..len).take_while(|&i| v1[i] == v2[i]).count() //0 => {
} //stream.append(&"");
//},
//1 => {
//stream.append_list(2);
//stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..], true));
//stream.append(&vec[0].data);
//},
//_ => {
//let shared_prefix = vec.iter()
//// skip first element
//.skip(1)
//// get minimum number of shared nibbles between first and each successive
//.fold(usize::max_value(), | acc, pair | {
//cmp::min(vec[0].nibble.shared_prefix_len(&pair.nibble), acc)
//});
fn hash256rlp(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
match vec.len() {
0 => stream.append(&""),
1 => stream.append_list(2).append(&hex_prefix_encode(&vec[0].nibble, true)).append(&vec[0].data),
_ => {
let shared_prefix = vec.iter()
// skip first element
.skip(1)
// get minimum number of shared nibbles between first string and each successive
.fold(usize::max_value(), | acc, pair | cmp::min(shared_prefix_length(&vec[0].nibble, &pair.nibble), acc) );
//match shared_prefix > pre_len { //match shared_prefix > pre_len {
//true => {
//stream.append_list(2);
//stream.append(&hex_prefix_encode(&vec[0].nibble[pre_len..shared_prefix], false));
//hash256aux(vec, shared_prefix, stream);
//},
//false => {
//stream.append_list(17);
//true => hex_prefix_encode(&vec[0].nibble //// every nibble is longer then previous one
//let iter = vec.iter()
//// move to first element with len different then pre_len
//.take_while(| pair | { pair.nibble.len() == pre_len });
//let mut begin = iter.count();
//for i in 0..16 {
//// cout how many successive elements have same next nibble
//let len = vec[begin..].iter()
//.map(| pair | pair.nibble[pre_len] )
//.take_while(|&q| q == i).count();
//match len {
//0 => { stream.append(&""); },
//_ => hash256aux(&vec[begin..begin + len], pre_len + 1, stream)
//}
//begin += len;
//}
//match pre_len == vec[0].nibble.len() {
//true => stream.append(&vec[0].data),
//false => stream.append(&"")
//};
//}
//} //}
panic!(); //}
//};
} //}
};
}
#[cfg(test)] //fn hash256aux(vec: &[NibblePair], pre_len: usize, stream: &mut RlpStream) {
mod tests { //let mut s = RlpStream::new();
} //hash256rlp(vec, pre_len, &mut s);
//let out = s.out().unwrap();
//match out.len() {
//0...31 => stream.append_raw(&out, 1),
//_ => stream.append(&out.sha3())
//};
//}
//#[cfg(test)]
//mod tests {
//use std::str::FromStr;
//use rustc_serialize::hex::FromHex;
//use hash::*;
//use triehash::*;
//#[test]
//fn empty_trie_root() {
//assert_eq!(hash256(&vec![]), H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap());
//}
//#[test]
//fn single_trie_item() {
//let v = vec![
//NibblePair::new_raw(From::from("A"),
//From::from("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
//];
//println!("{:?}", v);
//assert_eq!(hash256(&v), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap());
//}
//#[test]
//fn test_trie_root() {
//let v = vec![
//NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000045".from_hex().unwrap(),
//"22b224a1420a802ab51d326e29fa98e34c4f24ea".from_hex().unwrap()),
//NibblePair::new_raw("0000000000000000000000000000000000000000000000000000000000000046".from_hex().unwrap(),
//"67706c2076330000000000000000000000000000000000000000000000000000".from_hex().unwrap()),
//NibblePair::new_raw("000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap(),
//"6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap()),
//NibblePair::new_raw("0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap(),
//"4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap()),
//NibblePair::new_raw("000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap(),
//"4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap()),
//NibblePair::new_raw("4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap(),
//"7ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap()),
//NibblePair::new_raw("4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap(),
//"ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap()),
//NibblePair::new_raw("6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap(),
//"697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap())
//];
//let root = H256::from_str("9f6221ebb8efe7cff60a716ecb886e67dd042014be444669f0159d8e68b42100").unwrap();
//let res = hash256(&v);
//println!("{:?}", res);
////assert!(false);
//}
//}

37
src/vector.rs
View File

@ -1,3 +1,5 @@
//! vector util functions
use std::ptr; use std::ptr;
pub trait InsertSlice<T> { pub trait InsertSlice<T> {
@ -32,5 +34,38 @@ impl<T> InsertSlice<T> for Vec<T> {
} }
} }
pub trait SharedPreifx { /// Returns len of prefix shared with elem
///
/// ```rust
/// extern crate ethcore_util as util;
/// use util::vector::SharedPrefix;
///
/// fn main () {
/// let a = vec![1,2,3,3,5];
/// let b = vec![1,2,3];
/// assert_eq!(a.shared_prefix_len(&b), 3);
/// }
/// ```
pub trait SharedPrefix <T> {
fn shared_prefix_len(&self, elem: &[T]) -> usize;
}
impl <T> SharedPrefix<T> for Vec<T> where T: Eq {
fn shared_prefix_len(&self, elem: &[T]) -> usize {
use std::cmp;
let len = cmp::min(self.len(), elem.len());
(0..len).take_while(|&i| self[i] == elem[i]).count()
}
}
#[cfg(test)]
mod test {
use vector::SharedPrefix;
#[test]
fn test_shared_prefix() {
let a = vec![1,2,3,3,5];
let b = vec![1,2,3];
assert_eq!(a.shared_prefix_len(&b), 3);
}
} }