Merge branch 'master' into general-tests

This commit is contained in:
Nikolay Volf 2016-01-27 04:27:36 +04:00
commit 9225209086
21 changed files with 227 additions and 108 deletions

View File

@ -149,11 +149,15 @@ impl Account {
/// Provide a database to lookup `code_hash`. Should not be called if it is a contract without code. /// Provide a database to lookup `code_hash`. Should not be called if it is a contract without code.
pub fn cache_code(&mut self, db: &HashDB) -> bool { pub fn cache_code(&mut self, db: &HashDB) -> bool {
// TODO: fill out self.code_cache; // TODO: fill out self.code_cache;
trace!("Account::cache_code: ic={}; self.code_hash={:?}, self.code_cache={}", self.is_cached(), self.code_hash, self.code_cache.pretty());
self.is_cached() || self.is_cached() ||
match self.code_hash { match self.code_hash {
Some(ref h) => match db.lookup(h) { Some(ref h) => match db.lookup(h) {
Some(x) => { self.code_cache = x.to_vec(); true }, Some(x) => { self.code_cache = x.to_vec(); true },
_ => false, _ => {
warn!("Failed reverse lookup of {}", h);
false
},
}, },
_ => false, _ => false,
} }

View File

@ -5,80 +5,124 @@ use engine::*;
use state::*; use state::*;
use verification::PreVerifiedBlock; use verification::PreVerifiedBlock;
/// A transaction/receipt execution entry. /// A block, encoded as it is on the block chain.
pub struct Entry { // TODO: rename to Block
transaction: Transaction, #[derive(Default, Debug, Clone)]
receipt: Receipt, 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>,
}
impl Block {
/// Returns true iff 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()
}
}
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);
}
let d = try!(decoder.as_list());
if d.len() != 3 {
return Err(DecoderError::RlpIncorrectListLen);
}
Ok(Block {
header: try!(Decodable::decode(&d[0])),
transactions: try!(Decodable::decode(&d[1])),
uncles: try!(Decodable::decode(&d[2])),
})
}
} }
/// Internal type for a block's common elements. /// Internal type for a block's common elements.
pub struct Block { // TODO: rename to ExecutedBlock
header: Header, // TODO: use BareBlock
#[derive(Debug, Clone)]
pub struct ExecutedBlock {
base: Block,
/// State is the most final state in the block. receipts: Vec<Receipt>,
transactions_set: HashSet<H256>,
state: State, state: State,
archive: Vec<Entry>,
archive_set: HashSet<H256>,
uncles: Vec<Header>,
} }
/// A set of references to `Block` fields that are publicly accessible. /// A set of references to `ExecutedBlock` fields that are publicly accessible.
pub struct BlockRefMut<'a> { pub struct BlockRefMut<'a> {
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
pub header: &'a Header, pub header: &'a Header,
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
pub state: &'a mut State, pub transactions: &'a Vec<Transaction>,
/// TODO [Gav Wood] Please document me
pub archive: &'a Vec<Entry>,
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
pub uncles: &'a Vec<Header>, pub uncles: &'a Vec<Header>,
/// TODO [Gav Wood] Please document me
pub receipts: &'a Vec<Receipt>,
/// TODO [Gav Wood] Please document me
pub state: &'a mut State,
} }
impl Block { impl ExecutedBlock {
/// Create a new block from the given `state`. /// Create a new block from the given `state`.
fn new(state: State) -> Block { fn new(state: State) -> ExecutedBlock { ExecutedBlock { base: Default::default(), receipts: Default::default(), transactions_set: Default::default(), state: state } }
Block {
header: Header::new(),
state: state,
archive: Vec::new(),
archive_set: HashSet::new(),
uncles: Vec::new(),
}
}
/// Get a structure containing individual references to all public fields. /// Get a structure containing individual references to all public fields.
pub fn fields(&mut self) -> BlockRefMut { pub fn fields(&mut self) -> BlockRefMut {
BlockRefMut { BlockRefMut {
header: &self.header, header: &self.base.header,
transactions: &self.base.transactions,
uncles: &self.base.uncles,
state: &mut self.state, state: &mut self.state,
archive: &self.archive, receipts: &self.receipts,
uncles: &self.uncles,
} }
} }
} }
/// Trait for a object that is_a `Block`. /// Trait for a object that is_a `ExecutedBlock`.
pub trait IsBlock { pub trait IsBlock {
/// Get the block associated with this object. /// Get the block associated with this object.
fn block(&self) -> &Block; fn block(&self) -> &ExecutedBlock;
/// Get the header associated with this object's block. /// Get the header associated with this object's block.
fn header(&self) -> &Header { &self.block().header } fn header(&self) -> &Header { &self.block().base.header }
/// Get the final state associated with this object's block. /// Get the final state associated with this object's block.
fn state(&self) -> &State { &self.block().state } fn state(&self) -> &State { &self.block().state }
/// Get all information on transactions in this block. /// Get all information on transactions in this block.
fn archive(&self) -> &Vec<Entry> { &self.block().archive } 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 }
/// Get all uncles in this block. /// Get all uncles in this block.
fn uncles(&self) -> &Vec<Header> { &self.block().uncles } fn uncles(&self) -> &Vec<Header> { &self.block().base.uncles }
} }
impl IsBlock for Block { impl IsBlock for ExecutedBlock {
fn block(&self) -> &Block { self } fn block(&self) -> &ExecutedBlock { self }
} }
/// Block that is ready for transactions to be added. /// Block that is ready for transactions to be added.
@ -86,7 +130,7 @@ impl IsBlock for Block {
/// It's a bit like a Vec<Transaction>, eccept that whenever a transaction is pushed, we execute it and /// 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. /// maintain the system `state()`. We also archive execution receipts in preparation for later block creation.
pub struct OpenBlock<'x, 'y> { pub struct OpenBlock<'x, 'y> {
block: Block, block: ExecutedBlock,
engine: &'x Engine, engine: &'x Engine,
last_hashes: &'y LastHashes, last_hashes: &'y LastHashes,
} }
@ -104,7 +148,7 @@ pub struct ClosedBlock<'x, 'y> {
/// ///
/// The block's header has valid seal arguments. The block cannot be reversed into a ClosedBlock or OpenBlock. /// The block's header has valid seal arguments. The block cannot be reversed into a ClosedBlock or OpenBlock.
pub struct SealedBlock { pub struct SealedBlock {
block: Block, block: ExecutedBlock,
uncle_bytes: Bytes, uncle_bytes: Bytes,
} }
@ -112,42 +156,42 @@ impl<'x, 'y> OpenBlock<'x, 'y> {
/// Create a new OpenBlock ready for transaction pushing. /// Create a new OpenBlock ready for transaction pushing.
pub fn new<'a, 'b>(engine: &'a Engine, db: JournalDB, parent: &Header, last_hashes: &'b LastHashes, author: Address, extra_data: Bytes) -> OpenBlock<'a, 'b> { pub fn new<'a, 'b>(engine: &'a Engine, db: JournalDB, parent: &Header, last_hashes: &'b LastHashes, author: Address, extra_data: Bytes) -> OpenBlock<'a, 'b> {
let mut r = OpenBlock { let mut r = OpenBlock {
block: Block::new(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce())), block: ExecutedBlock::new(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce())),
engine: engine, engine: engine,
last_hashes: last_hashes, last_hashes: last_hashes,
}; };
r.block.header.set_number(parent.number() + 1); r.block.base.header.set_number(parent.number() + 1);
r.block.header.set_author(author); r.block.base.header.set_author(author);
r.block.header.set_extra_data(extra_data); r.block.base.header.set_extra_data(extra_data);
r.block.header.set_timestamp_now(); r.block.base.header.set_timestamp_now();
engine.populate_from_parent(&mut r.block.header, parent); engine.populate_from_parent(&mut r.block.base.header, parent);
engine.on_new_block(&mut r.block); engine.on_new_block(&mut r.block);
r r
} }
/// Alter the author for the block. /// Alter the author for the block.
pub fn set_author(&mut self, author: Address) { self.block.header.set_author(author); } pub fn set_author(&mut self, author: Address) { self.block.base.header.set_author(author); }
/// Alter the timestamp of the block. /// Alter the timestamp of the block.
pub fn set_timestamp(&mut self, timestamp: u64) { self.block.header.set_timestamp(timestamp); } pub fn set_timestamp(&mut self, timestamp: u64) { self.block.base.header.set_timestamp(timestamp); }
/// Alter the difficulty for the block. /// Alter the difficulty for the block.
pub fn set_difficulty(&mut self, a: U256) { self.block.header.set_difficulty(a); } pub fn set_difficulty(&mut self, a: U256) { self.block.base.header.set_difficulty(a); }
/// Alter the gas limit for the block. /// Alter the gas limit for the block.
pub fn set_gas_limit(&mut self, a: U256) { self.block.header.set_gas_limit(a); } pub fn set_gas_limit(&mut self, a: U256) { self.block.base.header.set_gas_limit(a); }
/// Alter the gas limit for the block. /// Alter the gas limit for the block.
pub fn set_gas_used(&mut self, a: U256) { self.block.header.set_gas_used(a); } pub fn set_gas_used(&mut self, a: U256) { self.block.base.header.set_gas_used(a); }
/// Alter the extra_data for the block. /// Alter the extra_data for the block.
pub fn set_extra_data(&mut self, extra_data: Bytes) -> Result<(), BlockError> { pub fn set_extra_data(&mut self, extra_data: Bytes) -> Result<(), BlockError> {
if extra_data.len() > self.engine.maximum_extra_data_size() { 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()})) Err(BlockError::ExtraDataOutOfBounds(OutOfBounds{min: None, max: Some(self.engine.maximum_extra_data_size()), found: extra_data.len()}))
} else { } else {
self.block.header.set_extra_data(extra_data); self.block.base.header.set_extra_data(extra_data);
Ok(()) Ok(())
} }
} }
@ -157,12 +201,12 @@ impl<'x, 'y> OpenBlock<'x, 'y> {
/// NOTE Will check chain constraints and the uncle number but will NOT check /// NOTE Will check chain constraints and the uncle number but will NOT check
/// that the header itself is actually valid. /// that the header itself is actually valid.
pub fn push_uncle(&mut self, valid_uncle_header: Header) -> Result<(), BlockError> { pub fn push_uncle(&mut self, valid_uncle_header: Header) -> Result<(), BlockError> {
if self.block.uncles.len() >= self.engine.maximum_uncle_count() { 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.uncles.len()})); return Err(BlockError::TooManyUncles(OutOfBounds{min: None, max: Some(self.engine.maximum_uncle_count()), found: self.block.base.uncles.len()}));
} }
// TODO: check number // TODO: check number
// TODO: check not a direct ancestor (use last_hashes for that) // TODO: check not a direct ancestor (use last_hashes for that)
self.block.uncles.push(valid_uncle_header); self.block.base.uncles.push(valid_uncle_header);
Ok(()) Ok(())
} }
@ -170,13 +214,13 @@ impl<'x, 'y> OpenBlock<'x, 'y> {
pub fn env_info(&self) -> EnvInfo { pub fn env_info(&self) -> EnvInfo {
// TODO: memoise. // TODO: memoise.
EnvInfo { EnvInfo {
number: self.block.header.number, number: self.block.base.header.number,
author: self.block.header.author.clone(), author: self.block.base.header.author.clone(),
timestamp: self.block.header.timestamp, timestamp: self.block.base.header.timestamp,
difficulty: self.block.header.difficulty.clone(), difficulty: self.block.base.header.difficulty.clone(),
last_hashes: self.last_hashes.clone(), // TODO: should be a reference. last_hashes: self.last_hashes.clone(), // TODO: should be a reference.
gas_used: self.block.archive.last().map_or(U256::zero(), |t| t.receipt.gas_used), gas_used: self.block.receipts.last().map_or(U256::zero(), |r| r.gas_used),
gas_limit: self.block.header.gas_limit.clone(), gas_limit: self.block.base.header.gas_limit.clone(),
} }
} }
@ -188,9 +232,10 @@ impl<'x, 'y> OpenBlock<'x, 'y> {
// info!("env_info says gas_used={}", env_info.gas_used); // info!("env_info says gas_used={}", env_info.gas_used);
match self.block.state.apply(&env_info, self.engine, &t) { match self.block.state.apply(&env_info, self.engine, &t) {
Ok(receipt) => { Ok(receipt) => {
self.block.archive_set.insert(h.unwrap_or_else(||t.hash())); self.block.transactions_set.insert(h.unwrap_or_else(||t.hash()));
self.block.archive.push(Entry { transaction: t, receipt: receipt }); self.block.base.transactions.push(t);
Ok(&self.block.archive.last().unwrap().receipt) self.block.receipts.push(receipt);
Ok(&self.block.receipts.last().unwrap())
} }
Err(x) => Err(From::from(x)) Err(x) => Err(From::from(x))
} }
@ -200,25 +245,25 @@ impl<'x, 'y> OpenBlock<'x, 'y> {
pub fn close(self) -> ClosedBlock<'x, 'y> { pub fn close(self) -> ClosedBlock<'x, 'y> {
let mut s = self; let mut s = self;
s.engine.on_close_block(&mut s.block); s.engine.on_close_block(&mut s.block);
s.block.header.transactions_root = ordered_trie_root(s.block.archive.iter().map(|ref e| e.transaction.rlp_bytes()).collect()); s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes()).collect());
let uncle_bytes = s.block.uncles.iter().fold(RlpStream::new_list(s.block.uncles.len()), |mut s, u| {s.append(&u.rlp(Seal::With)); s} ).out(); 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.header.uncles_hash = uncle_bytes.sha3(); s.block.base.header.uncles_hash = uncle_bytes.sha3();
s.block.header.state_root = s.block.state.root().clone(); s.block.base.header.state_root = s.block.state.root().clone();
s.block.header.receipts_root = ordered_trie_root(s.block.archive.iter().map(|ref e| e.receipt.rlp_bytes()).collect()); s.block.base.header.receipts_root = ordered_trie_root(s.block.receipts.iter().map(|ref r| r.rlp_bytes()).collect());
s.block.header.log_bloom = s.block.archive.iter().fold(LogBloom::zero(), |mut b, e| {b |= &e.receipt.log_bloom; b}); s.block.base.header.log_bloom = s.block.receipts.iter().fold(LogBloom::zero(), |mut b, r| {b |= &r.log_bloom; b});
s.block.header.gas_used = s.block.archive.last().map_or(U256::zero(), |t| t.receipt.gas_used); s.block.base.header.gas_used = s.block.receipts.last().map_or(U256::zero(), |r| r.gas_used);
s.block.header.note_dirty(); s.block.base.header.note_dirty();
ClosedBlock::new(s, uncle_bytes) ClosedBlock::new(s, uncle_bytes)
} }
} }
impl<'x, 'y> IsBlock for OpenBlock<'x, 'y> { impl<'x, 'y> IsBlock for OpenBlock<'x, 'y> {
fn block(&self) -> &Block { &self.block } fn block(&self) -> &ExecutedBlock { &self.block }
} }
impl<'x, 'y> IsBlock for ClosedBlock<'x, 'y> { impl<'x, 'y> IsBlock for ClosedBlock<'x, 'y> {
fn block(&self) -> &Block { &self.open_block.block } fn block(&self) -> &ExecutedBlock { &self.open_block.block }
} }
impl<'x, 'y> ClosedBlock<'x, 'y> { impl<'x, 'y> ClosedBlock<'x, 'y> {
@ -240,7 +285,7 @@ impl<'x, 'y> ClosedBlock<'x, 'y> {
if seal.len() != s.open_block.engine.seal_fields() { if seal.len() != s.open_block.engine.seal_fields() {
return Err(BlockError::InvalidSealArity(Mismatch{expected: s.open_block.engine.seal_fields(), found: seal.len()})); return Err(BlockError::InvalidSealArity(Mismatch{expected: s.open_block.engine.seal_fields(), found: seal.len()}));
} }
s.open_block.block.header.set_seal(seal); s.open_block.block.base.header.set_seal(seal);
Ok(SealedBlock { block: s.open_block.block, uncle_bytes: s.uncle_bytes }) Ok(SealedBlock { block: s.open_block.block, uncle_bytes: s.uncle_bytes })
} }
@ -255,9 +300,9 @@ impl SealedBlock {
/// Get the RLP-encoding of the block. /// Get the RLP-encoding of the block.
pub fn rlp_bytes(&self) -> Bytes { pub fn rlp_bytes(&self) -> Bytes {
let mut block_rlp = RlpStream::new_list(3); let mut block_rlp = RlpStream::new_list(3);
self.block.header.stream_rlp(&mut block_rlp, Seal::With); self.block.base.header.stream_rlp(&mut block_rlp, Seal::With);
block_rlp.append_list(self.block.archive.len()); block_rlp.append_list(self.block.receipts.len());
for e in &self.block.archive { e.transaction.rlp_append(&mut block_rlp); } for t in &self.block.base.transactions { t.rlp_append(&mut block_rlp); }
block_rlp.append_raw(&self.uncle_bytes, 1); block_rlp.append_raw(&self.uncle_bytes, 1);
block_rlp.out() block_rlp.out()
} }
@ -267,7 +312,7 @@ impl SealedBlock {
} }
impl IsBlock for SealedBlock { impl IsBlock for SealedBlock {
fn block(&self) -> &Block { &self.block } fn block(&self) -> &ExecutedBlock { &self.block }
} }
/// Enact the block given by block header, transactions and uncles /// Enact the block given by block header, transactions and uncles

View File

@ -158,6 +158,7 @@ impl BlockQueue {
}, },
Err(err) => { Err(err) => {
let mut v = verification.lock().unwrap(); let mut v = verification.lock().unwrap();
flushln!("Stage 2 block verification failed for {}\nError: {:?}", block_hash, err);
warn!(target: "client", "Stage 2 block verification failed for {}\nError: {:?}", block_hash, err); warn!(target: "client", "Stage 2 block verification failed for {}\nError: {:?}", block_hash, err);
v.bad.insert(block_hash.clone()); v.bad.insert(block_hash.clone());
v.verifying.retain(|e| e.hash != block_hash); v.verifying.retain(|e| e.hash != block_hash);
@ -221,6 +222,7 @@ impl BlockQueue {
self.more_to_verify.notify_all(); self.more_to_verify.notify_all();
}, },
Err(err) => { Err(err) => {
flushln!("Stage 1 block verification failed for {}\nError: {:?}", BlockView::new(&bytes).header_view().sha3(), err);
warn!(target: "client", "Stage 1 block verification failed for {}\nError: {:?}", BlockView::new(&bytes).header_view().sha3(), err); warn!(target: "client", "Stage 1 block verification failed for {}\nError: {:?}", BlockView::new(&bytes).header_view().sha3(), err);
self.verification.lock().unwrap().bad.insert(header.hash()); self.verification.lock().unwrap().bad.insert(header.hash());
} }

View File

@ -107,6 +107,11 @@ pub trait BlockProvider {
fn genesis_hash(&self) -> H256 { fn genesis_hash(&self) -> H256 {
self.block_hash(0).expect("Genesis hash should always exist") self.block_hash(0).expect("Genesis hash should always exist")
} }
/// Returns the header of the genesis block.
fn genesis_header(&self) -> Header {
self.block_header(&self.genesis_hash()).unwrap()
}
} }
#[derive(Debug, Hash, Eq, PartialEq, Clone)] #[derive(Debug, Hash, Eq, PartialEq, Clone)]

View File

@ -4,8 +4,10 @@ use blockchain::{BlockChain, BlockProvider, CacheSize};
use views::BlockView; use views::BlockView;
use error::*; use error::*;
use header::BlockNumber; use header::BlockNumber;
use state::State;
use spec::Spec; use spec::Spec;
use engine::Engine; use engine::Engine;
use views::HeaderView;
use block_queue::{BlockQueue, BlockQueueInfo}; use block_queue::{BlockQueue, BlockQueueInfo};
use service::NetSyncMessage; use service::NetSyncMessage;
use env_info::LastHashes; use env_info::LastHashes;
@ -98,6 +100,11 @@ pub trait BlockChainClient : Sync + Send {
/// Get blockchain information. /// Get blockchain information.
fn chain_info(&self) -> BlockChainInfo; fn chain_info(&self) -> BlockChainInfo;
/// Get the best block header.
fn best_block_header(&self) -> Bytes {
self.block_header(&self.chain_info().best_block_hash).unwrap()
}
} }
#[derive(Default, Clone, Debug, Eq, PartialEq)] #[derive(Default, Clone, Debug, Eq, PartialEq)]
@ -137,7 +144,8 @@ const HISTORY: u64 = 1000;
impl Client { impl Client {
/// Create a new client with given spec and DB path. /// Create a new client with given spec and DB path.
pub fn new(spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Result<Arc<Client>, Error> { pub fn new(spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Result<Arc<Client>, Error> {
let chain = Arc::new(RwLock::new(BlockChain::new(&spec.genesis_block(), path))); let gb = spec.genesis_block();
let chain = Arc::new(RwLock::new(BlockChain::new(&gb, path)));
let mut opts = Options::new(); let mut opts = Options::new();
opts.set_max_open_files(256); opts.set_max_open_files(256);
opts.create_if_missing(true); opts.create_if_missing(true);
@ -190,6 +198,7 @@ impl Client {
let _import_lock = self.import_lock.lock(); let _import_lock = self.import_lock.lock();
let blocks = self.block_queue.write().unwrap().drain(128); let blocks = self.block_queue.write().unwrap().drain(128);
for block in blocks { for block in blocks {
// flushln!("Importing {}...", block.header.hash());
if bad.contains(&block.header.parent_hash) { if bad.contains(&block.header.parent_hash) {
self.block_queue.write().unwrap().mark_as_bad(&block.header.hash()); self.block_queue.write().unwrap().mark_as_bad(&block.header.hash());
bad.insert(block.header.hash()); bad.insert(block.header.hash());
@ -198,6 +207,7 @@ impl Client {
let header = &block.header; let header = &block.header;
if let Err(e) = verify_block_family(&header, &block.bytes, self.engine.deref().deref(), self.chain.read().unwrap().deref()) { if let Err(e) = verify_block_family(&header, &block.bytes, self.engine.deref().deref(), self.chain.read().unwrap().deref()) {
flushln!("Stage 3 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
warn!(target: "client", "Stage 3 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e); warn!(target: "client", "Stage 3 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
self.block_queue.write().unwrap().mark_as_bad(&header.hash()); self.block_queue.write().unwrap().mark_as_bad(&header.hash());
bad.insert(block.header.hash()); bad.insert(block.header.hash());
@ -206,6 +216,7 @@ impl Client {
let parent = match self.chain.read().unwrap().block_header(&header.parent_hash) { let parent = match self.chain.read().unwrap().block_header(&header.parent_hash) {
Some(p) => p, Some(p) => p,
None => { None => {
flushln!("Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash);
warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash); warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash);
self.block_queue.write().unwrap().mark_as_bad(&header.hash()); self.block_queue.write().unwrap().mark_as_bad(&header.hash());
bad.insert(block.header.hash()); bad.insert(block.header.hash());
@ -229,8 +240,9 @@ impl Client {
let result = match enact_verified(&block, self.engine.deref().deref(), db, &parent, &last_hashes) { let result = match enact_verified(&block, self.engine.deref().deref(), db, &parent, &last_hashes) {
Ok(b) => b, Ok(b) => b,
Err(e) => { Err(e) => {
flushln!("Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e); warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
bad.insert(block.header.hash()); bad.insert(block.header.hash());
self.block_queue.write().unwrap().mark_as_bad(&header.hash()); self.block_queue.write().unwrap().mark_as_bad(&header.hash());
return; return;
} }
@ -261,6 +273,11 @@ impl Client {
self.uncommited_states.write().unwrap().remove(hash); self.uncommited_states.write().unwrap().remove(hash);
} }
/// Get a copy of the best block's state.
pub fn state(&self) -> State {
State::from_existing(self.state_db.clone(), HeaderView::new(&self.best_block_header()).state_root(), self.engine.account_start_nonce())
}
/// Get info on the cache. /// Get info on the cache.
pub fn cache_info(&self) -> CacheSize { pub fn cache_info(&self) -> CacheSize {
self.chain.read().unwrap().cache_size() self.chain.read().unwrap().cache_size()

View File

@ -1,5 +1,5 @@
use common::*; use common::*;
use block::Block; use block::ExecutedBlock;
use spec::Spec; use spec::Spec;
use evm::Schedule; use evm::Schedule;
use evm::Factory; use evm::Factory;
@ -37,9 +37,9 @@ pub trait Engine : Sync + Send {
fn account_start_nonce(&self) -> U256 { decode(&self.spec().engine_params.get("accountStartNonce").unwrap()) } fn account_start_nonce(&self) -> U256 { decode(&self.spec().engine_params.get("accountStartNonce").unwrap()) }
/// Block transformation functions, before and after the transactions. /// Block transformation functions, before and after the transactions.
fn on_new_block(&self, _block: &mut Block) {} fn on_new_block(&self, _block: &mut ExecutedBlock) {}
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
fn on_close_block(&self, _block: &mut Block) {} fn on_close_block(&self, _block: &mut ExecutedBlock) {}
// TODO: consider including State in the params for verification functions. // TODO: consider including State in the params for verification functions.
/// Phase 1 quick block verification. Only does checks that are cheap. `block` (the header's full block) /// Phase 1 quick block verification. Only does checks that are cheap. `block` (the header's full block)

View File

@ -83,7 +83,7 @@ impl Engine for Ethash {
/// Apply the block reward on finalisation of the block. /// Apply the block reward on finalisation of the block.
/// This assumes that all uncles are valid uncles (i.e. of at least one generation before the current). /// This assumes that all uncles are valid uncles (i.e. of at least one generation before the current).
fn on_close_block(&self, block: &mut Block) { fn on_close_block(&self, block: &mut ExecutedBlock) {
let reward = self.spec().engine_params.get("blockReward").map_or(U256::from(0u64), |a| decode(&a)); let reward = self.spec().engine_params.get("blockReward").map_or(U256::from(0u64), |a| decode(&a));
let fields = block.fields(); let fields = block.fields();
@ -99,6 +99,10 @@ impl Engine for Ethash {
} }
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> { fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
// check the seal fields.
try!(UntrustedRlp::new(&header.seal[0]).as_val::<H256>());
try!(UntrustedRlp::new(&header.seal[1]).as_val::<u64>());
let min_difficulty = decode(self.spec().engine_params.get("minimumDifficulty").unwrap()); let min_difficulty = decode(self.spec().engine_params.get("minimumDifficulty").unwrap());
if header.difficulty < min_difficulty { if header.difficulty < min_difficulty {
return Err(From::from(BlockError::InvalidDifficulty(Mismatch { expected: min_difficulty, found: header.difficulty }))) return Err(From::from(BlockError::InvalidDifficulty(Mismatch { expected: min_difficulty, found: header.difficulty })))

View File

@ -295,7 +295,6 @@ impl<'a> Executive<'a> {
// perform suicides // perform suicides
for address in &substate.suicides { for address in &substate.suicides {
trace!("Killing {}", address);
self.state.kill_account(address); self.state.kill_account(address);
} }

View File

@ -215,6 +215,7 @@ impl<'a> Ext for Externalities<'a> {
fn suicide(&mut self, refund_address: &Address) { fn suicide(&mut self, refund_address: &Address) {
let address = self.origin_info.address.clone(); let address = self.origin_info.address.clone();
let balance = self.balance(&address); let balance = self.balance(&address);
trace!("Suiciding {} -> {} (xfer: {})", address, refund_address, balance);
self.state.transfer_balance(&address, refund_address, &balance); self.state.transfer_balance(&address, refund_address, &balance);
self.substate.suicides.insert(address); self.substate.suicides.insert(address);
} }

View File

@ -11,7 +11,7 @@ pub type BlockNumber = u64;
/// which is non-specific. /// which is non-specific.
/// ///
/// Doesn't do all that much on its own. /// Doesn't do all that much on its own.
#[derive(Debug, Clone)] #[derive(Default, Debug, Clone)]
pub struct Header { pub struct Header {
// TODO: make all private. // TODO: make all private.
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me

View File

@ -2,7 +2,7 @@ use util::*;
use basic_types::LogBloom; use basic_types::LogBloom;
/// A single log's entry. /// A single log's entry.
#[derive(Debug,PartialEq,Eq)] #[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct LogEntry { pub struct LogEntry {
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
pub address: Address, pub address: Address,

View File

@ -31,7 +31,7 @@ impl PodAccount {
} }
} }
/// TODO [Gav Wood] Please document me /// Returns the RLP for this account.
pub fn rlp(&self) -> Bytes { pub fn rlp(&self) -> Bytes {
let mut stream = RlpStream::new_list(4); let mut stream = RlpStream::new_list(4);
stream.append(&self.nonce); stream.append(&self.nonce);
@ -40,6 +40,18 @@ impl PodAccount {
stream.append(&self.code.sha3()); stream.append(&self.code.sha3());
stream.out() stream.out()
} }
/// Place additional data into given hash DB.
pub fn insert_additional(&self, db: &mut HashDB) {
if !self.code.is_empty() {
db.insert(&self.code);
}
let mut r = H256::new();
let mut t = SecTrieDBMut::new(db, &mut r);
for (k, v) in &self.storage {
t.insert(k, &encode(&U256::from(v.as_slice())));
}
}
} }
impl fmt::Display for PodAccount { impl fmt::Display for PodAccount {

View File

@ -3,7 +3,7 @@ use basic_types::LogBloom;
use log_entry::LogEntry; use log_entry::LogEntry;
/// Information describing execution of a transaction. /// Information describing execution of a transaction.
#[derive(Debug)] #[derive(Default, Debug, Clone)]
pub struct Receipt { pub struct Receipt {
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
pub state_root: H256, pub state_root: H256,

View File

@ -261,7 +261,6 @@ impl Spec {
/// Ensure that the given state DB has the trie nodes in for the genesis state. /// Ensure that the given state DB has the trie nodes in for the genesis state.
pub fn ensure_db_good(&self, db: &mut HashDB) -> bool { pub fn ensure_db_good(&self, db: &mut HashDB) -> bool {
if !db.contains(&self.state_root()) { if !db.contains(&self.state_root()) {
info!("Populating genesis state...");
let mut root = H256::new(); let mut root = H256::new();
{ {
let mut t = SecTrieDBMut::new(db, &mut root); let mut t = SecTrieDBMut::new(db, &mut root);
@ -269,8 +268,10 @@ impl Spec {
t.insert(address.as_slice(), &account.rlp()); t.insert(address.as_slice(), &account.rlp());
} }
} }
for (_, account) in self.genesis_state.get().iter() {
account.insert_additional(db);
}
assert!(db.contains(&self.state_root())); assert!(db.contains(&self.state_root()));
info!("Genesis state is ready");
true true
} else { false } } else { false }
} }

View File

@ -2,6 +2,7 @@ use std::env;
use super::test_common::*; use super::test_common::*;
use client::{BlockChainClient,Client}; use client::{BlockChainClient,Client};
use pod_state::*; use pod_state::*;
use block::Block;
use ethereum; use ethereum;
fn do_json_test(json_data: &[u8]) -> Vec<String> { fn do_json_test(json_data: &[u8]) -> Vec<String> {
@ -22,7 +23,8 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
let blocks: Vec<Bytes> = test["blocks"].as_array().unwrap().iter().map(|e| xjson!(&e["rlp"])).collect(); let blocks: Vec<Bytes> = test["blocks"].as_array().unwrap().iter().map(|e| xjson!(&e["rlp"])).collect();
let mut spec = ethereum::new_frontier_like_test(); let mut spec = ethereum::new_frontier_like_test();
spec.set_genesis_state(PodState::from_json(test.find("pre").unwrap())); let s = PodState::from_json(test.find("pre").unwrap());
spec.set_genesis_state(s);
spec.overwrite_genesis(test.find("genesisBlockHeader").unwrap()); spec.overwrite_genesis(test.find("genesisBlockHeader").unwrap());
assert!(spec.is_state_root_valid()); assert!(spec.is_state_root_valid());
@ -30,9 +32,9 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
dir.push(H32::random().hex()); dir.push(H32::random().hex());
{ {
let client = Client::new(spec, &dir, IoChannel::disconnected()).unwrap(); let client = Client::new(spec, &dir, IoChannel::disconnected()).unwrap();
blocks.into_iter().foreach(|b| { for b in blocks.into_iter().filter(|ref b| Block::is_good(b)) {
client.import_block(b).unwrap(); client.import_block(b).unwrap();
}); }
client.flush_queue(); client.flush_queue();
client.import_verified_blocks(&IoChannel::disconnected()); client.import_verified_blocks(&IoChannel::disconnected());
fail_unless(client.chain_info().best_block_hash == H256::from_json(&test["lastblockhash"])); fail_unless(client.chain_info().best_block_hash == H256::from_json(&test["lastblockhash"]));
@ -47,18 +49,18 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
failed failed
} }
declare_test!{ignore => BlockchainTests_bcBlockGasLimitTest, "BlockchainTests/bcBlockGasLimitTest"} // FAILS declare_test!{BlockchainTests_bcBlockGasLimitTest, "BlockchainTests/bcBlockGasLimitTest"}
declare_test!{BlockchainTests_bcForkBlockTest, "BlockchainTests/bcForkBlockTest"} declare_test!{BlockchainTests_bcForkBlockTest, "BlockchainTests/bcForkBlockTest"}
declare_test!{ignore => BlockchainTests_bcForkStressTest, "BlockchainTests/bcForkStressTest"} // FAILS declare_test!{BlockchainTests_bcForkStressTest, "BlockchainTests/bcForkStressTest"} // STILL FAILS
declare_test!{ignore => BlockchainTests_bcForkUncle, "BlockchainTests/bcForkUncle"} // FAILS declare_test!{BlockchainTests_bcForkUncle, "BlockchainTests/bcForkUncle"} // STILL FAILS
declare_test!{BlockchainTests_bcGasPricerTest, "BlockchainTests/bcGasPricerTest"} declare_test!{BlockchainTests_bcGasPricerTest, "BlockchainTests/bcGasPricerTest"}
declare_test!{BlockchainTests_bcInvalidHeaderTest, "BlockchainTests/bcInvalidHeaderTest"} declare_test!{BlockchainTests_bcInvalidHeaderTest, "BlockchainTests/bcInvalidHeaderTest"}
declare_test!{ignore => BlockchainTests_bcInvalidRLPTest, "BlockchainTests/bcInvalidRLPTest"} // FAILS declare_test!{BlockchainTests_bcInvalidRLPTest, "BlockchainTests/bcInvalidRLPTest"} // FAILS
declare_test!{ignore => BlockchainTests_bcMultiChainTest, "BlockchainTests/bcMultiChainTest"} // FAILS declare_test!{BlockchainTests_bcMultiChainTest, "BlockchainTests/bcMultiChainTest"} // FAILS
declare_test!{BlockchainTests_bcRPC_API_Test, "BlockchainTests/bcRPC_API_Test"} declare_test!{BlockchainTests_bcRPC_API_Test, "BlockchainTests/bcRPC_API_Test"}
declare_test!{ignore => BlockchainTests_bcStateTest, "BlockchainTests/bcStateTest"} // FAILS (Suicides, GasUsed) declare_test!{BlockchainTests_bcStateTest, "BlockchainTests/bcStateTest"}
declare_test!{BlockchainTests_bcTotalDifficultyTest, "BlockchainTests/bcTotalDifficultyTest"} declare_test!{BlockchainTests_bcTotalDifficultyTest, "BlockchainTests/bcTotalDifficultyTest"}
declare_test!{ignore => BlockchainTests_bcUncleHeaderValiditiy, "BlockchainTests/bcUncleHeaderValiditiy"} // FAILS declare_test!{BlockchainTests_bcUncleHeaderValiditiy, "BlockchainTests/bcUncleHeaderValiditiy"} // FAILS
declare_test!{ignore => BlockchainTests_bcUncleTest, "BlockchainTests/bcUncleTest"} // FAILS declare_test!{BlockchainTests_bcUncleTest, "BlockchainTests/bcUncleTest"} // FAILS
declare_test!{ignore => BlockchainTests_bcValidBlockTest, "BlockchainTests/bcValidBlockTest"} // FAILS declare_test!{BlockchainTests_bcValidBlockTest, "BlockchainTests/bcValidBlockTest"} // FAILS
declare_test!{ignore => BlockchainTests_bcWalletTest, "BlockchainTests/bcWalletTest"} // FAILS declare_test!{BlockchainTests_bcWalletTest, "BlockchainTests/bcWalletTest"} // FAILS

View File

@ -3,7 +3,7 @@ use basic_types::*;
use error::*; use error::*;
use evm::Schedule; use evm::Schedule;
#[derive(Debug,Clone)] #[derive(Debug, Clone)]
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
pub enum Action { pub enum Action {
/// TODO [Gav Wood] Please document me /// TODO [Gav Wood] Please document me
@ -12,9 +12,13 @@ pub enum Action {
Call(Address), Call(Address),
} }
impl Default for Action {
fn default() -> Action { Action::Create }
}
/// A set of information describing an externally-originating message call /// A set of information describing an externally-originating message call
/// or contract creation operation. /// or contract creation operation.
#[derive(Debug,Clone)] #[derive(Default, Debug, Clone)]
pub struct Transaction { pub struct Transaction {
/// TODO [debris] Please document me /// TODO [debris] Please document me
pub nonce: U256, pub nonce: U256,

View File

@ -273,7 +273,9 @@ pub enum FromBytesError {
/// TODO [debris] Please document me /// TODO [debris] Please document me
DataIsTooShort, DataIsTooShort,
/// TODO [debris] Please document me /// TODO [debris] Please document me
DataIsTooLong DataIsTooLong,
/// Integer-representation is non-canonically prefixed with zero byte(s).
ZeroPrefixedInt,
} }
impl StdError for FromBytesError { impl StdError for FromBytesError {
@ -310,6 +312,9 @@ macro_rules! impl_uint_from_bytes {
match bytes.len() { match bytes.len() {
0 => Ok(0), 0 => Ok(0),
l if l <= mem::size_of::<$to>() => { l if l <= mem::size_of::<$to>() => {
if bytes[0] == 0 {
return Err(FromBytesError::ZeroPrefixedInt)
}
let mut res = 0 as $to; let mut res = 0 as $to;
for i in 0..l { for i in 0..l {
let shift = (l - 1 - i) * 8; let shift = (l - 1 - i) * 8;
@ -344,7 +349,9 @@ macro_rules! impl_uint_from_bytes {
($name: ident) => { ($name: ident) => {
impl FromBytes for $name { impl FromBytes for $name {
fn from_bytes(bytes: &[u8]) -> FromBytesResult<$name> { fn from_bytes(bytes: &[u8]) -> FromBytesResult<$name> {
if bytes.len() <= $name::SIZE { if !bytes.is_empty() && bytes[0] == 0 {
Err(FromBytesError::ZeroPrefixedInt)
} else if bytes.len() <= $name::SIZE {
Ok($name::from(bytes)) Ok($name::from(bytes))
} else { } else {
Err(FromBytesError::DataIsTooLong) Err(FromBytesError::DataIsTooLong)

View File

@ -7,6 +7,8 @@ use bytes::FromBytesError;
pub enum DecoderError { pub enum DecoderError {
/// TODO [debris] Please document me /// TODO [debris] Please document me
FromBytesError(FromBytesError), FromBytesError(FromBytesError),
/// Given data has additional bytes at the end of the valid RLP fragment.
RlpIsTooBig,
/// TODO [debris] Please document me /// TODO [debris] Please document me
RlpIsTooShort, RlpIsTooShort,
/// TODO [debris] Please document me /// TODO [debris] Please document me

View File

@ -46,6 +46,9 @@ impl PayloadInfo {
value_len: value_len, value_len: value_len,
} }
} }
/// Total size of the RLP.
pub fn total(&self) -> usize { self.header_len + self.value_len }
} }
/// Data-oriented view onto rlp-slice. /// Data-oriented view onto rlp-slice.

View File

@ -25,6 +25,12 @@ impl<'db> SecTrieDBMut<'db> {
pub fn from_existing(db: &'db mut HashDB, root: &'db mut H256) -> Self { pub fn from_existing(db: &'db mut HashDB, root: &'db mut H256) -> Self {
SecTrieDBMut { raw: TrieDBMut::from_existing(db, root) } SecTrieDBMut { raw: TrieDBMut::from_existing(db, root) }
} }
/// Get the backing database.
pub fn db(&'db self) -> &'db HashDB { self.raw.db() }
/// Get the backing database.
pub fn db_mut(&'db mut self) -> &'db mut HashDB { self.raw.db_mut() }
} }
impl<'db> Trie for SecTrieDBMut<'db> { impl<'db> Trie for SecTrieDBMut<'db> {

View File

@ -87,6 +87,11 @@ impl<'db> TrieDBMut<'db> {
self.db self.db
} }
/// Get the backing database.
pub fn db_mut(&'db mut self) -> &'db mut HashDB {
self.db
}
/// Determine all the keys in the backing database that belong to the trie. /// Determine all the keys in the backing database that belong to the trie.
pub fn keys(&self) -> Vec<H256> { pub fn keys(&self) -> Vec<H256> {
let mut ret: Vec<H256> = Vec::new(); let mut ret: Vec<H256> = Vec::new();