openethereum/ethcore/src/block.rs

399 lines
14 KiB
Rust
Raw Normal View History

2016-02-02 15:29:53 +01:00
//! Blockchain block.
2016-01-19 11:10:38 +01:00
#![allow(ptr_arg)] // Because of &LastHashes -> &Vec<_>
use common::*;
2016-01-08 19:12:19 +01:00
use engine::*;
2016-01-08 21:33:41 +01:00
use state::*;
2016-01-17 23:07:58 +01:00
use verification::PreVerifiedBlock;
2016-01-08 19:12:19 +01:00
/// A block, encoded as it is on the block chain.
// TODO: rename to Block
#[derive(Default, Debug, Clone)]
2016-01-08 19:12:19 +01:00
pub struct Block {
/// The header of this block.
pub header: Header,
/// The transactions in this block.
pub transactions: Vec<Transaction>,
/// The uncles of this block.
pub uncles: Vec<Header>,
}
2016-01-08 19:12:19 +01:00
impl Block {
/// Returns true if the given bytes form a valid encoding of a block in RLP.
// TODO: implement Decoder for this and have this use that.
pub fn is_good(b: &[u8]) -> bool {
/*
let urlp = UntrustedRlp::new(&b);
if !urlp.is_list() || urlp.item_count() != 3 || urlp.size() != b.len() { return false; }
if urlp.val_at::<Header>(0).is_err() { return false; }
if !urlp.at(1).unwrap().is_list() { return false; }
if urlp.at(1).unwrap().iter().find(|i| i.as_val::<Transaction>().is_err()).is_some() {
return false;
}
if !urlp.at(2).unwrap().is_list() { return false; }
if urlp.at(2).unwrap().iter().find(|i| i.as_val::<Header>().is_err()).is_some() {
return false;
}
true*/
UntrustedRlp::new(b).as_val::<Block>().is_ok()
}
}
2016-01-08 19:12:19 +01:00
impl Decodable for Block {
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
if decoder.as_raw().len() != try!(decoder.as_rlp().payload_info()).total() {
return Err(DecoderError::RlpIsTooBig);
}
2016-01-29 13:59:29 +01:00
let d = decoder.as_rlp();
if d.item_count() != 3 {
return Err(DecoderError::RlpIncorrectListLen);
}
Ok(Block {
2016-01-29 13:59:29 +01:00
header: try!(d.val_at(0)),
transactions: try!(d.val_at(1)),
uncles: try!(d.val_at(2)),
})
}
}
2016-01-10 14:05:39 +01:00
/// Internal type for a block's common elements.
// TODO: rename to ExecutedBlock
// TODO: use BareBlock
#[derive(Debug, Clone)]
pub struct ExecutedBlock {
base: Block,
receipts: Vec<Receipt>,
transactions_set: HashSet<H256>,
state: State,
2016-01-08 19:12:19 +01:00
}
/// A set of references to `ExecutedBlock` fields that are publicly accessible.
2016-01-10 17:11:46 +01:00
pub struct BlockRefMut<'a> {
/// Block header.
2016-01-10 17:11:46 +01:00
pub header: &'a Header,
/// Block transactions.
pub transactions: &'a Vec<Transaction>,
/// Block uncles.
2016-01-10 17:11:46 +01:00
pub uncles: &'a Vec<Header>,
/// Transaction receipts.
pub receipts: &'a Vec<Receipt>,
/// State.
pub state: &'a mut State,
2016-01-10 17:11:46 +01:00
}
impl ExecutedBlock {
2016-01-10 17:11:46 +01:00
/// Create a new block from the given `state`.
fn new(state: State) -> ExecutedBlock { ExecutedBlock { base: Default::default(), receipts: Default::default(), transactions_set: Default::default(), state: state } }
2016-01-08 19:12:19 +01:00
2016-01-10 17:11:46 +01:00
/// Get a structure containing individual references to all public fields.
pub fn fields(&mut self) -> BlockRefMut {
BlockRefMut {
header: &self.base.header,
transactions: &self.base.transactions,
uncles: &self.base.uncles,
state: &mut self.state,
receipts: &self.receipts,
}
}
2016-01-08 19:12:19 +01:00
}
/// Trait for a object that is_a `ExecutedBlock`.
2016-01-08 21:33:41 +01:00
pub trait IsBlock {
2016-01-08 19:12:19 +01:00
/// Get the block associated with this object.
fn block(&self) -> &ExecutedBlock;
2016-01-08 19:12:19 +01:00
/// Get the header associated with this object's block.
fn header(&self) -> &Header { &self.block().base.header }
2016-01-08 19:12:19 +01:00
/// Get the final state associated with this object's block.
2016-01-08 21:33:41 +01:00
fn state(&self) -> &State { &self.block().state }
2016-01-08 19:12:19 +01:00
/// Get all information on transactions in this block.
fn transactions(&self) -> &Vec<Transaction> { &self.block().base.transactions }
/// Get all information on receipts in this block.
fn receipts(&self) -> &Vec<Receipt> { &self.block().receipts }
2016-01-10 14:05:39 +01:00
/// Get all uncles in this block.
fn uncles(&self) -> &Vec<Header> { &self.block().base.uncles }
2016-01-08 19:12:19 +01:00
}
impl IsBlock for ExecutedBlock {
fn block(&self) -> &ExecutedBlock { self }
2016-01-08 19:12:19 +01:00
}
2016-01-08 22:04:21 +01:00
2016-01-08 19:12:19 +01:00
/// Block that is ready for transactions to be added.
///
/// It's a bit like a Vec<Transaction>, eccept that whenever a transaction is pushed, we execute it and
/// maintain the system `state()`. We also archive execution receipts in preparation for later block creation.
pub struct OpenBlock<'x, 'y> {
block: ExecutedBlock,
engine: &'x Engine,
last_hashes: &'y LastHashes,
2016-01-08 19:12:19 +01:00
}
/// Just like OpenBlock, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
/// and collected the uncles.
///
/// There is no function available to push a transaction. If you want that you'll need to `reopen()` it.
pub struct ClosedBlock<'x, 'y> {
open_block: OpenBlock<'x, 'y>,
2016-01-10 14:05:39 +01:00
uncle_bytes: Bytes,
2016-01-08 19:12:19 +01:00
}
/// A block that has a valid seal.
///
/// The block's header has valid seal arguments. The block cannot be reversed into a ClosedBlock or OpenBlock.
pub struct SealedBlock {
block: ExecutedBlock,
2016-01-10 14:05:39 +01:00
uncle_bytes: Bytes,
2016-01-08 19:12:19 +01:00
}
impl<'x, 'y> OpenBlock<'x, 'y> {
2016-01-08 22:04:21 +01:00
/// Create a new OpenBlock ready for transaction pushing.
2016-01-18 13:54:46 +01:00
pub fn new<'a, 'b>(engine: &'a Engine, db: JournalDB, parent: &Header, last_hashes: &'b LastHashes, author: Address, extra_data: Bytes) -> OpenBlock<'a, 'b> {
2016-01-08 19:12:19 +01:00
let mut r = OpenBlock {
block: ExecutedBlock::new(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce())),
2016-01-08 19:12:19 +01:00
engine: engine,
last_hashes: last_hashes,
2016-01-08 22:04:21 +01:00
};
2016-01-08 19:12:19 +01:00
r.block.base.header.set_number(parent.number() + 1);
r.block.base.header.set_author(author);
r.block.base.header.set_extra_data(extra_data);
r.block.base.header.set_timestamp_now();
engine.populate_from_parent(&mut r.block.base.header, parent);
2016-01-08 22:04:21 +01:00
engine.on_new_block(&mut r.block);
2016-01-08 19:12:19 +01:00
r
}
2016-01-10 14:05:39 +01:00
/// Alter the author for the block.
pub fn set_author(&mut self, author: Address) { self.block.base.header.set_author(author); }
2016-01-10 14:05:39 +01:00
/// Alter the timestamp of the block.
pub fn set_timestamp(&mut self, timestamp: u64) { self.block.base.header.set_timestamp(timestamp); }
2016-01-15 23:32:17 +01:00
/// Alter the difficulty for the block.
pub fn set_difficulty(&mut self, a: U256) { self.block.base.header.set_difficulty(a); }
2016-01-15 23:32:17 +01:00
/// Alter the gas limit for the block.
pub fn set_gas_limit(&mut self, a: U256) { self.block.base.header.set_gas_limit(a); }
2016-01-15 23:32:17 +01:00
/// Alter the gas limit for the block.
pub fn set_gas_used(&mut self, a: U256) { self.block.base.header.set_gas_used(a); }
2016-01-15 23:32:17 +01:00
2016-01-10 14:05:39 +01:00
/// Alter the extra_data for the block.
pub fn set_extra_data(&mut self, extra_data: Bytes) -> Result<(), BlockError> {
if extra_data.len() > self.engine.maximum_extra_data_size() {
Err(BlockError::ExtraDataOutOfBounds(OutOfBounds{min: None, max: Some(self.engine.maximum_extra_data_size()), found: extra_data.len()}))
2016-01-10 14:05:39 +01:00
} else {
self.block.base.header.set_extra_data(extra_data);
2016-01-10 14:05:39 +01:00
Ok(())
}
}
/// Add an uncle to the block, if possible.
///
/// NOTE Will check chain constraints and the uncle number but will NOT check
/// that the header itself is actually valid.
pub fn push_uncle(&mut self, valid_uncle_header: Header) -> Result<(), BlockError> {
if self.block.base.uncles.len() >= self.engine.maximum_uncle_count() {
return Err(BlockError::TooManyUncles(OutOfBounds{min: None, max: Some(self.engine.maximum_uncle_count()), found: self.block.base.uncles.len()}));
2016-01-10 14:05:39 +01:00
}
// TODO: check number
// TODO: check not a direct ancestor (use last_hashes for that)
self.block.base.uncles.push(valid_uncle_header);
2016-01-10 14:05:39 +01:00
Ok(())
}
2016-01-08 22:04:21 +01:00
/// Get the environment info concerning this block.
pub fn env_info(&self) -> EnvInfo {
// TODO: memoise.
EnvInfo {
number: self.block.base.header.number,
author: self.block.base.header.author.clone(),
timestamp: self.block.base.header.timestamp,
difficulty: self.block.base.header.difficulty.clone(),
2016-01-15 23:32:17 +01:00
last_hashes: self.last_hashes.clone(), // TODO: should be a reference.
gas_used: self.block.receipts.last().map_or(U256::zero(), |r| r.gas_used),
gas_limit: self.block.base.header.gas_limit.clone(),
2016-01-08 22:04:21 +01:00
}
}
2016-01-10 14:05:39 +01:00
/// Push a transaction into the block.
///
/// If valid, it will be executed, and archived together with the receipt.
pub fn push_transaction(&mut self, t: Transaction, h: Option<H256>) -> Result<&Receipt, Error> {
2016-01-08 22:04:21 +01:00
let env_info = self.env_info();
2016-01-15 23:32:17 +01:00
// info!("env_info says gas_used={}", env_info.gas_used);
2016-01-11 13:29:15 +01:00
match self.block.state.apply(&env_info, self.engine, &t) {
2016-01-11 17:37:22 +01:00
Ok(receipt) => {
self.block.transactions_set.insert(h.unwrap_or_else(||t.hash()));
self.block.base.transactions.push(t);
self.block.receipts.push(receipt);
Ok(&self.block.receipts.last().unwrap())
2016-01-08 19:12:19 +01:00
}
2016-01-11 17:37:22 +01:00
Err(x) => Err(From::from(x))
2016-01-08 19:12:19 +01:00
}
}
2016-01-09 18:26:35 +01:00
/// Turn this into a `ClosedBlock`. A BlockChain must be provided in order to figure out the uncles.
pub fn close(self) -> ClosedBlock<'x, 'y> {
2016-01-09 22:45:27 +01:00
let mut s = self;
s.engine.on_close_block(&mut s.block);
s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes().to_vec()).collect());
let uncle_bytes = s.block.base.uncles.iter().fold(RlpStream::new_list(s.block.base.uncles.len()), |mut s, u| {s.append(&u.rlp(Seal::With)); s} ).out();
s.block.base.header.uncles_hash = uncle_bytes.sha3();
s.block.base.header.state_root = s.block.state.root().clone();
s.block.base.header.receipts_root = ordered_trie_root(s.block.receipts.iter().map(|ref r| r.rlp_bytes().to_vec()).collect());
s.block.base.header.log_bloom = s.block.receipts.iter().fold(LogBloom::zero(), |mut b, r| {b |= &r.log_bloom; b});
s.block.base.header.gas_used = s.block.receipts.last().map_or(U256::zero(), |r| r.gas_used);
s.block.base.header.note_dirty();
2016-01-09 22:45:27 +01:00
ClosedBlock::new(s, uncle_bytes)
}
2016-01-08 19:12:19 +01:00
}
impl<'x, 'y> IsBlock for OpenBlock<'x, 'y> {
fn block(&self) -> &ExecutedBlock { &self.block }
2016-01-08 19:12:19 +01:00
}
impl<'x, 'y> IsBlock for ClosedBlock<'x, 'y> {
fn block(&self) -> &ExecutedBlock { &self.open_block.block }
2016-01-10 14:05:39 +01:00
}
impl<'x, 'y> ClosedBlock<'x, 'y> {
fn new<'a, 'b>(open_block: OpenBlock<'a, 'b>, uncle_bytes: Bytes) -> ClosedBlock<'a, 'b> {
ClosedBlock {
open_block: open_block,
2016-01-10 14:05:39 +01:00
uncle_bytes: uncle_bytes,
}
}
2016-01-08 19:12:19 +01:00
/// Get the hash of the header without seal arguments.
2016-01-10 14:05:39 +01:00
pub fn hash(&self) -> H256 { self.header().rlp_sha3(Seal::Without) }
2016-01-08 19:12:19 +01:00
2016-01-10 14:05:39 +01:00
/// Provide a valid seal in order to turn this into a `SealedBlock`.
///
/// NOTE: This does not check the validity of `seal` with the engine.
pub fn seal(self, seal: Vec<Bytes>) -> Result<SealedBlock, BlockError> {
let mut s = self;
if seal.len() != s.open_block.engine.seal_fields() {
return Err(BlockError::InvalidSealArity(Mismatch{expected: s.open_block.engine.seal_fields(), found: seal.len()}));
}
s.open_block.block.base.header.set_seal(seal);
2016-01-10 14:05:39 +01:00
Ok(SealedBlock { block: s.open_block.block, uncle_bytes: s.uncle_bytes })
}
2016-01-08 19:12:19 +01:00
/// Turn this back into an `OpenBlock`.
pub fn reopen(self) -> OpenBlock<'x, 'y> { self.open_block }
2016-01-14 19:03:48 +01:00
/// Drop this object and return the underlieing database.
2016-01-18 13:54:46 +01:00
pub fn drain(self) -> JournalDB { self.open_block.block.state.drop().1 }
2016-01-08 19:12:19 +01:00
}
impl SealedBlock {
2016-01-10 14:05:39 +01:00
/// Get the RLP-encoding of the block.
pub fn rlp_bytes(&self) -> Bytes {
let mut block_rlp = RlpStream::new_list(3);
self.block.base.header.stream_rlp(&mut block_rlp, Seal::With);
2016-01-28 20:13:05 +01:00
block_rlp.append(&self.block.base.transactions);
2016-01-10 14:05:39 +01:00
block_rlp.append_raw(&self.uncle_bytes, 1);
block_rlp.out()
2016-01-10 23:10:06 +01:00
}
/// Drop this object and return the underlieing database.
2016-01-18 13:54:46 +01:00
pub fn drain(self) -> JournalDB { self.block.state.drop().1 }
2016-01-08 19:12:19 +01:00
}
impl IsBlock for SealedBlock {
fn block(&self) -> &ExecutedBlock { &self.block }
2016-01-08 19:12:19 +01:00
}
2016-01-17 23:07:58 +01:00
/// Enact the block given by block header, transactions and uncles
2016-01-18 16:20:35 +01:00
pub fn enact<'x, 'y>(header: &Header, transactions: &[Transaction], uncles: &[Header], engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: &'y LastHashes) -> Result<ClosedBlock<'x, 'y>, Error> {
2016-01-15 22:55:04 +01:00
{
let s = State::from_existing(db.clone(), parent.state_root().clone(), engine.account_start_nonce());
2016-01-16 01:48:38 +01:00
trace!("enact(): root={}, author={}, author_balance={}\n", s.root(), header.author(), s.balance(&header.author()));
2016-01-15 22:55:04 +01:00
}
2016-01-15 23:32:17 +01:00
2016-01-17 23:07:58 +01:00
let mut b = OpenBlock::new(engine, db, parent, last_hashes, header.author().clone(), header.extra_data().clone());
b.set_difficulty(*header.difficulty());
b.set_gas_limit(*header.gas_limit());
2016-01-10 22:57:31 +01:00
b.set_timestamp(header.timestamp());
2016-01-17 23:07:58 +01:00
for t in transactions { try!(b.push_transaction(t.clone(), None)); }
for u in uncles { try!(b.push_uncle(u.clone())); }
2016-01-14 19:03:48 +01:00
Ok(b.close())
}
2016-01-17 23:07:58 +01:00
/// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
2016-01-18 16:20:35 +01:00
pub fn enact_bytes<'x, 'y>(block_bytes: &[u8], engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: &'y LastHashes) -> Result<ClosedBlock<'x, 'y>, Error> {
2016-01-17 23:07:58 +01:00
let block = BlockView::new(block_bytes);
let header = block.header();
enact(&header, &block.transactions(), &block.uncles(), engine, db, parent, last_hashes)
}
/// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
2016-01-18 16:20:35 +01:00
pub fn enact_verified<'x, 'y>(block: &PreVerifiedBlock, engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: &'y LastHashes) -> Result<ClosedBlock<'x, 'y>, Error> {
2016-01-17 23:07:58 +01:00
let view = BlockView::new(&block.bytes);
enact(&block.header, &block.transactions, &view.uncles(), engine, db, parent, last_hashes)
}
2016-01-14 19:03:48 +01:00
/// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
2016-01-18 13:54:46 +01:00
pub fn enact_and_seal(block_bytes: &[u8], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: &LastHashes) -> Result<SealedBlock, Error> {
2016-01-14 19:03:48 +01:00
let header = BlockView::new(block_bytes).header_view();
2016-01-17 23:07:58 +01:00
Ok(try!(try!(enact_bytes(block_bytes, engine, db, parent, last_hashes)).seal(header.seal())))
}
#[cfg(test)]
mod tests {
use tests::helpers::*;
use super::*;
use common::*;
use engine::*;
#[test]
fn open_block() {
use spec::*;
let engine = Spec::new_test().to_engine().unwrap();
let genesis_header = engine.spec().genesis_header();
let mut db_result = get_temp_journal_db();
let db = db_result.reference_mut();
engine.spec().ensure_db_good(db);
let last_hashes = vec![genesis_header.hash()];
let b = OpenBlock::new(engine.deref(), db.clone(), &genesis_header, &last_hashes, Address::zero(), vec![]);
let b = b.close();
let _ = b.seal(vec![]);
}
2016-01-10 23:10:06 +01:00
#[test]
fn enact_block() {
use spec::*;
let engine = Spec::new_test().to_engine().unwrap();
let genesis_header = engine.spec().genesis_header();
let mut db_result = get_temp_journal_db();
let db = db_result.reference_mut();
engine.spec().ensure_db_good(db);
let b = OpenBlock::new(engine.deref(), db.clone(), &genesis_header, &vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(vec![]).unwrap();
let orig_bytes = b.rlp_bytes();
let orig_db = b.drain();
let mut db_result = get_temp_journal_db();
let db = db_result.reference_mut();
engine.spec().ensure_db_good(db);
let e = enact_and_seal(&orig_bytes, engine.deref(), db.clone(), &genesis_header, &vec![genesis_header.hash()]).unwrap();
assert_eq!(e.rlp_bytes(), orig_bytes);
let db = e.drain();
assert_eq!(orig_db.keys(), db.keys());
assert!(orig_db.keys().iter().filter(|k| orig_db.get(k.0) != db.get(k.0)).next() == None);
}
2016-02-02 15:29:53 +01:00
}