2015-12-08 16:31:36 +01:00
|
|
|
use util::hash::*;
|
|
|
|
use util::uint::*;
|
|
|
|
use util::rlp::*;
|
|
|
|
|
2015-12-09 19:03:25 +01:00
|
|
|
/// view onto block header rlp
|
|
|
|
pub struct BlockView<'a> {
|
|
|
|
rlp: Rlp<'a>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> BlockView<'a> {
|
|
|
|
pub fn new(bytes: &'a [u8]) -> BlockView<'a> {
|
|
|
|
BlockView {
|
|
|
|
rlp: Rlp::new(bytes)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn parent_hash(&self) -> H256 { self.rlp.val_at(0) }
|
|
|
|
pub fn uncles_hash(&self) -> H256 { self.rlp.val_at(1) }
|
|
|
|
pub fn coinbase(&self) -> Address { self.rlp.val_at(2) }
|
|
|
|
pub fn state_root(&self) -> H256 { self.rlp.val_at(3) }
|
|
|
|
pub fn transactions_root(&self) -> H256 { self.rlp.val_at(4) }
|
|
|
|
pub fn receipts_root(&self) -> H256 { self.rlp.val_at(5) }
|
|
|
|
pub fn log_bloom(&self) -> H2048 { self.rlp.val_at(6) }
|
|
|
|
pub fn difficulty(&self) -> U256 { self.rlp.val_at(7) }
|
|
|
|
pub fn number(&self) -> U256 { self.rlp.val_at(8) }
|
|
|
|
pub fn gas_limit(&self) -> U256 { self.rlp.val_at(9) }
|
|
|
|
pub fn gas_usd(&self) -> U256 { self.rlp.val_at(10) }
|
|
|
|
pub fn timestamp(&self) -> U256 { self.rlp.val_at(11) }
|
|
|
|
pub fn mix_hash(&self) -> H256 { self.rlp.val_at(12) }
|
|
|
|
pub fn nonce(&self) -> H64 { self.rlp.val_at(13) }
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Data structure represening block header
|
2015-12-08 16:31:36 +01:00
|
|
|
pub struct BlockHeader {
|
|
|
|
parent_hash: H256,
|
2015-12-09 19:03:25 +01:00
|
|
|
uncles_hash: H256,
|
|
|
|
coinbase: Address,
|
2015-12-08 16:31:36 +01:00
|
|
|
state_root: H256,
|
|
|
|
transactions_root: H256,
|
|
|
|
receipts_root: H256,
|
|
|
|
log_bloom: H2048,
|
|
|
|
difficulty: U256,
|
|
|
|
number: U256,
|
|
|
|
gas_limit: U256,
|
|
|
|
gas_used: U256,
|
|
|
|
timestamp: U256,
|
|
|
|
mix_hash: H256,
|
|
|
|
nonce: H64
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Decodable for BlockHeader {
|
|
|
|
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
|
|
|
|
decoder.read_list(| d | {
|
2015-12-09 19:03:25 +01:00
|
|
|
// return an error if d != 14
|
2015-12-08 16:31:36 +01:00
|
|
|
let blockheader = BlockHeader {
|
2015-12-08 16:36:44 +01:00
|
|
|
parent_hash: try!(Decodable::decode(&d[0])),
|
2015-12-09 19:03:25 +01:00
|
|
|
uncles_hash: try!(Decodable::decode(&d[1])),
|
|
|
|
coinbase: try!(Decodable::decode(&d[2])),
|
2015-12-08 16:36:44 +01:00
|
|
|
state_root: try!(Decodable::decode(&d[3])),
|
|
|
|
transactions_root: try!(Decodable::decode(&d[4])),
|
|
|
|
receipts_root: try!(Decodable::decode(&d[5])),
|
|
|
|
log_bloom: try!(Decodable::decode(&d[6])),
|
|
|
|
difficulty: try!(Decodable::decode(&d[7])),
|
|
|
|
number: try!(Decodable::decode(&d[8])),
|
|
|
|
gas_limit: try!(Decodable::decode(&d[9])),
|
|
|
|
gas_used: try!(Decodable::decode(&d[10])),
|
|
|
|
timestamp: try!(Decodable::decode(&d[11])),
|
|
|
|
mix_hash: try!(Decodable::decode(&d[12])),
|
|
|
|
nonce: try!(Decodable::decode(&d[13]))
|
2015-12-08 16:31:36 +01:00
|
|
|
};
|
|
|
|
Ok(blockheader)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Encodable for BlockHeader {
|
|
|
|
fn encode<E>(&self, encoder: &mut E) where E: Encoder {
|
|
|
|
encoder.emit_list(| e | {
|
|
|
|
self.parent_hash.encode(e);
|
2015-12-09 19:03:25 +01:00
|
|
|
self.uncles_hash.encode(e);
|
|
|
|
self.coinbase.encode(e);
|
2015-12-08 16:31:36 +01:00
|
|
|
self.state_root.encode(e);
|
|
|
|
self.transactions_root.encode(e);
|
|
|
|
self.receipts_root.encode(e);
|
|
|
|
self.log_bloom.encode(e);
|
|
|
|
self.difficulty.encode(e);
|
|
|
|
self.number.encode(e);
|
|
|
|
self.gas_limit.encode(e);
|
|
|
|
self.gas_used.encode(e);
|
|
|
|
self.timestamp.encode(e);
|
|
|
|
self.mix_hash.encode(e);
|
|
|
|
self.nonce.encode(e);
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-09 00:45:33 +01:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
fn encoding_and_decoding() {
|
|
|
|
}
|
|
|
|
}
|