From 2cc3ee66d7103004e3ce8f4b51036b333fd64246 Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Sun, 10 Jan 2016 17:09:02 +0100 Subject: [PATCH 1/9] Allow fields to be returned so they can be used simultaneously. --- src/block.rs | 17 ++++++++++++++++- src/ethereum/ethash.rs | 12 ++++++++++-- 2 files changed, 26 insertions(+), 3 deletions(-) diff --git a/src/block.rs b/src/block.rs index ac43be23b..fe6474306 100644 --- a/src/block.rs +++ b/src/block.rs @@ -8,6 +8,14 @@ pub struct Entry { receipt: Receipt, } +/// A set of fields that are publicly alterable. +pub struct BlockRefMut<'a> { + pub header: &'a Header, + pub state: &'a mut State, + pub archive: &'a Vec, + pub uncles: &'a Vec
, +} + /// Internal type for a block's common elements. pub struct Block { header: Header, @@ -32,7 +40,14 @@ impl Block { } } - pub fn state_mut(&mut self) -> &mut State { &mut self.state } + pub fn fields(&mut self) -> BlockRefMut { + BlockRefMut { + header: &self.header, + state: &mut self.state, + archive: &self.archive, + uncles: &self.uncles, + } + } } /// Trait for a object that is_a `Block`. diff --git a/src/ethereum/ethash.rs b/src/ethereum/ethash.rs index f959c3d1d..75b7aa17f 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -22,8 +22,16 @@ impl Engine for Ethash { /// Apply the block reward on finalisation of the block. fn on_close_block(&self, block: &mut Block) { - let a = block.header().author.clone(); - block.state_mut().add_balance(&a, &decode(&self.spec().engine_params.get("blockReward").unwrap())); + let reward = self.spec().engine_params.get("blockReward").map(|a| decode(&a)).unwrap_or(U256::from(0u64)); + let fields = block.fields(); + let author = &fields.header.author; + fields.state.add_balance(author, &reward); +/* + let uncle_authors = block.uncles.iter().map(|u| u.author().clone()).collect(); + for a in uncle_authors { + block.state_mut().addBalance(a, _blockReward * (8 + i.number() - m_currentBlock.number()) / 8); + r += _blockReward / 32; + }*/ } } From fea418703b9a038363d2a77733429ed4f50f48fa Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Sun, 10 Jan 2016 17:11:46 +0100 Subject: [PATCH 2/9] Better API allowing one fewer clone. --- src/block.rs | 18 ++++++++++-------- src/ethereum/ethash.rs | 3 +-- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/src/block.rs b/src/block.rs index fe6474306..1c8f787ad 100644 --- a/src/block.rs +++ b/src/block.rs @@ -8,14 +8,6 @@ pub struct Entry { receipt: Receipt, } -/// A set of fields that are publicly alterable. -pub struct BlockRefMut<'a> { - pub header: &'a Header, - pub state: &'a mut State, - pub archive: &'a Vec, - pub uncles: &'a Vec
, -} - /// Internal type for a block's common elements. pub struct Block { header: Header, @@ -29,7 +21,16 @@ pub struct Block { uncles: Vec
, } +/// A set of references to `Block` fields that are publicly accessible. +pub struct BlockRefMut<'a> { + pub header: &'a Header, + pub state: &'a mut State, + pub archive: &'a Vec, + pub uncles: &'a Vec
, +} + impl Block { + /// Create a new block from the given `state`. fn new(state: State) -> Block { Block { header: Header::new(), @@ -40,6 +41,7 @@ impl Block { } } + /// Get a structure containing individual references to all public fields. pub fn fields(&mut self) -> BlockRefMut { BlockRefMut { header: &self.header, diff --git a/src/ethereum/ethash.rs b/src/ethereum/ethash.rs index 75b7aa17f..5922832b3 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -24,8 +24,7 @@ impl Engine for Ethash { fn on_close_block(&self, block: &mut Block) { let reward = self.spec().engine_params.get("blockReward").map(|a| decode(&a)).unwrap_or(U256::from(0u64)); let fields = block.fields(); - let author = &fields.header.author; - fields.state.add_balance(author, &reward); + fields.state.add_balance(&fields.header.author, &reward); /* let uncle_authors = block.uncles.iter().map(|u| u.author().clone()).collect(); for a in uncle_authors { From 4f68662e53513b78d0b10b3cb10bae97f0a4d6a3 Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Sun, 10 Jan 2016 21:55:03 +0100 Subject: [PATCH 3/9] Proper rewarding; needs consensus test doing though. --- src/block.rs | 4 ++-- src/env_info.rs | 4 ++-- src/ethereum/ethash.rs | 20 ++++++++++++-------- src/header.rs | 9 +++++---- src/spec.rs | 8 ++++---- 5 files changed, 25 insertions(+), 20 deletions(-) diff --git a/src/block.rs b/src/block.rs index 1c8f787ad..475e2c390 100644 --- a/src/block.rs +++ b/src/block.rs @@ -148,9 +148,9 @@ impl<'engine> OpenBlock<'engine> { pub fn env_info(&self) -> EnvInfo { // TODO: memoise. EnvInfo { - number: self.block.header.number.clone(), + number: self.block.header.number, author: self.block.header.author.clone(), - timestamp: self.block.header.timestamp.clone(), + timestamp: self.block.header.timestamp, difficulty: self.block.header.difficulty.clone(), last_hashes: self.last_hashes.clone(), gas_used: self.block.archive.last().map(|t| t.receipt.gas_used).unwrap_or(U256::from(0)), diff --git a/src/env_info.rs b/src/env_info.rs index 919db314d..e7c8ae261 100644 --- a/src/env_info.rs +++ b/src/env_info.rs @@ -7,11 +7,11 @@ pub type LastHashes = Vec; /// Information concerning the execution environment for a message-call/contract-creation. pub struct EnvInfo { /// The block number. - pub number: U256, + pub number: usize, /// The block author. pub author: Address, /// The block timestamp. - pub timestamp: U256, + pub timestamp: usize, /// The block difficulty. pub difficulty: U256, /// The block gas limit. diff --git a/src/ethereum/ethash.rs b/src/ethereum/ethash.rs index 5922832b3..1c955a91f 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -17,20 +17,24 @@ impl Ethash { impl Engine for Ethash { fn name(&self) -> &str { "Ethash" } + fn version(&self) -> SemanticVersion { SemanticVersion::new(1, 0, 0) } fn spec(&self) -> &Spec { &self.spec } fn evm_schedule(&self, _env_info: &EnvInfo) -> EvmSchedule { EvmSchedule::new_frontier() } /// 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). fn on_close_block(&self, block: &mut Block) { let reward = self.spec().engine_params.get("blockReward").map(|a| decode(&a)).unwrap_or(U256::from(0u64)); let fields = block.fields(); - fields.state.add_balance(&fields.header.author, &reward); -/* - let uncle_authors = block.uncles.iter().map(|u| u.author().clone()).collect(); - for a in uncle_authors { - block.state_mut().addBalance(a, _blockReward * (8 + i.number() - m_currentBlock.number()) / 8); - r += _blockReward / 32; - }*/ + + // Bestow block reward + fields.state.add_balance(&fields.header.author, &(reward + reward / U256::from(32) * U256::from(fields.uncles.len()))); + + // Bestow uncle rewards + let current_number = fields.header.number(); + for u in fields.uncles.iter() { + fields.state.add_balance(u.author(), &(reward * U256::from((8 + u.number() - current_number) / 8))); + } } } @@ -43,5 +47,5 @@ fn on_close_block() { engine.spec().ensure_db_good(&mut db); let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]); let b = b.close(); - assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244F40000").unwrap()); + assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244f40000").unwrap()); } \ No newline at end of file diff --git a/src/header.rs b/src/header.rs index a1666ef04..b90538009 100644 --- a/src/header.rs +++ b/src/header.rs @@ -11,8 +11,8 @@ use basic_types::*; pub struct Header { // TODO: make all private. pub parent_hash: H256, - pub timestamp: U256, - pub number: U256, + pub timestamp: usize, + pub number: usize, pub author: Address, pub transactions_root: H256, @@ -41,8 +41,8 @@ impl Header { pub fn new() -> Header { Header { parent_hash: ZERO_H256.clone(), - timestamp: BAD_U256.clone(), - number: ZERO_U256.clone(), + timestamp: 0, + number: 0, author: ZERO_ADDRESS.clone(), transactions_root: ZERO_H256.clone(), @@ -64,6 +64,7 @@ impl Header { pub fn author(&self) -> &Address { &self.author } pub fn extra_data(&self) -> &Bytes { &self.extra_data } pub fn seal(&self) -> &Vec { &self.seal } + pub fn number(&self) -> usize { self.number } // TODO: seal_at, set_seal_at &c. diff --git a/src/spec.rs b/src/spec.rs index 377b9c0df..2ba1fa10c 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -60,7 +60,7 @@ pub struct Spec { pub difficulty: U256, pub gas_limit: U256, pub gas_used: U256, - pub timestamp: U256, + pub timestamp: usize, pub extra_data: Bytes, pub genesis_state: HashMap, pub seal_fields: usize, @@ -92,8 +92,8 @@ impl Spec { pub fn genesis_header(&self) -> Header { Header { parent_hash: self.parent_hash.clone(), - timestamp: self.timestamp.clone(), - number: U256::from(0u8), + timestamp: self.timestamp, + number: 0, author: self.author.clone(), transactions_root: SHA3_NULL_RLP.clone(), uncles_hash: RlpStream::new_list(0).out().sha3(), @@ -181,7 +181,7 @@ impl Spec { difficulty: U256::from_str(&genesis["difficulty"].as_string().unwrap()[2..]).unwrap(), gas_limit: U256::from_str(&genesis["gasLimit"].as_string().unwrap()[2..]).unwrap(), gas_used: U256::from(0u8), - timestamp: U256::from_str(&genesis["timestamp"].as_string().unwrap()[2..]).unwrap(), + timestamp: usize::from_str(&genesis["timestamp"].as_string().unwrap()[2..]).unwrap(), extra_data: genesis["extraData"].as_string().unwrap()[2..].from_hex().unwrap(), genesis_state: state, seal_fields: seal_fields, From 74f88f9b9bc66a72a7a6a400453f26fc37a9d79a Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Sun, 10 Jan 2016 22:55:07 +0100 Subject: [PATCH 4/9] Initial implementation of enacted. number is now usize, timestamp u64. --- Cargo.toml | 1 + src/block.rs | 58 +++++++++++++++++++++++++++++++----------- src/blockchain.rs | 55 ++++++++++++++++++++------------------- src/env_info.rs | 2 +- src/ethereum/ethash.rs | 12 +++++++-- src/extras.rs | 9 ++++++- src/header.rs | 17 ++++++++++--- src/lib.rs | 1 + src/spec.rs | 4 +-- src/views.rs | 4 +-- 10 files changed, 108 insertions(+), 55 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 64b49663f..f5e0fd420 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,7 @@ flate2 = "0.2" rocksdb = "0.2.1" heapsize = "0.2.0" rust-crypto = "0.2.34" +time = "0.1" evmjit = { path = "rust-evmjit", optional = true } diff --git a/src/block.rs b/src/block.rs index 475e2c390..0794fcfc5 100644 --- a/src/block.rs +++ b/src/block.rs @@ -78,18 +78,18 @@ impl IsBlock for Block { /// /// It's a bit like a Vec, 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<'engine> { +pub struct OpenBlock<'x, 'y> { block: Block, - engine: &'engine Engine, - last_hashes: LastHashes, + engine: &'x Engine, + last_hashes: &'y LastHashes, } /// 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<'engine> { - open_block: OpenBlock<'engine>, +pub struct ClosedBlock<'x, 'y> { + open_block: OpenBlock<'x, 'y>, uncle_bytes: Bytes, } @@ -101,9 +101,9 @@ pub struct SealedBlock { uncle_bytes: Bytes, } -impl<'engine> OpenBlock<'engine> { +impl<'x, 'y> OpenBlock<'x, 'y> { /// Create a new OpenBlock ready for transaction pushing. - pub fn new<'a>(engine: &'a Engine, db: OverlayDB, parent: &Header, last_hashes: LastHashes, author: Address, extra_data: Bytes) -> OpenBlock<'a> { + pub fn new<'a, 'b>(engine: &'a Engine, db: OverlayDB, parent: &Header, last_hashes: &'b LastHashes, author: Address, extra_data: Bytes) -> OpenBlock<'a, 'b> { let mut r = OpenBlock { block: Block::new(State::from_existing(db, parent.state_root.clone(), engine.account_start_nonce())), engine: engine, @@ -112,6 +112,8 @@ impl<'engine> OpenBlock<'engine> { r.block.header.set_author(author); r.block.header.set_extra_data(extra_data); + r.block.header.set_timestamp_now(); + engine.populate_from_parent(&mut r.block.header, parent); engine.on_new_block(&mut r.block); r @@ -120,6 +122,9 @@ impl<'engine> OpenBlock<'engine> { /// Alter the author for the block. pub fn set_author(&mut self, author: Address) { self.block.header.set_author(author); } + /// Alter the timestamp of the block. + pub fn set_timestamp(&mut self, timestamp: u64) { self.block.header.set_timestamp(timestamp); } + /// 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() { @@ -174,7 +179,7 @@ impl<'engine> OpenBlock<'engine> { } /// Turn this into a `ClosedBlock`. A BlockChain must be provided in order to figure out the uncles. - pub fn close(self) -> ClosedBlock<'engine> { + pub fn close(self) -> ClosedBlock<'x, 'y> { let mut s = self; 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()); @@ -190,16 +195,16 @@ impl<'engine> OpenBlock<'engine> { } } -impl<'engine> IsBlock for OpenBlock<'engine> { +impl<'x, 'y> IsBlock for OpenBlock<'x, 'y> { fn block(&self) -> &Block { &self.block } } -impl<'engine> IsBlock for ClosedBlock<'engine> { +impl<'x, 'y> IsBlock for ClosedBlock<'x, 'y> { fn block(&self) -> &Block { &self.open_block.block } } -impl<'engine> ClosedBlock<'engine> { - fn new<'a>(open_block: OpenBlock<'a>, uncle_bytes: Bytes) -> ClosedBlock<'a> { +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, uncle_bytes: uncle_bytes, @@ -222,7 +227,7 @@ impl<'engine> ClosedBlock<'engine> { } /// Turn this back into an `OpenBlock`. - pub fn reopen(self) -> OpenBlock<'engine> { self.open_block } + pub fn reopen(self) -> OpenBlock<'x, 'y> { self.open_block } } impl SealedBlock { @@ -241,6 +246,15 @@ impl IsBlock for SealedBlock { fn block(&self) -> &Block { &self.block } } +pub fn enacted(rlp_bytes: &[u8], db: OverlayDB, engine: &Engine, parent: &Header, last_hashes: &LastHashes) -> Result { + let block = BlockView::new(rlp_bytes); + let header = block.header_view(); + let mut b = OpenBlock::new(engine, db, parent, last_hashes, header.author(), header.extra_data()); + for t in block.transactions().into_iter() { try!(b.push_transaction(t, None)); } + for u in block.uncles().into_iter() { try!(b.push_uncle(u)); } + Ok(try!(b.close().seal(header.seal()))) +} + #[test] fn open_block() { use spec::*; @@ -248,7 +262,21 @@ fn open_block() { let genesis_header = engine.spec().genesis_header(); let mut db = OverlayDB::new_temp(); engine.spec().ensure_db_good(&mut db); - let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]); + let last_hashes = vec![genesis_header.hash()]; + let b = OpenBlock::new(engine.deref(), db, &genesis_header, &last_hashes, Address::zero(), vec![]); let b = b.close(); let _ = b.seal(vec![]); -} \ No newline at end of file +} +/* +#[test] +fn enact_block() { + use spec::*; + let engine = Spec::new_test().to_engine().unwrap(); + let genesis_header = engine.spec().genesis_header(); + let mut db = OverlayDB::new_temp(); + engine.spec().ensure_db_good(&mut db); + + let b = OpenBlock::new(engine.deref(), db, &genesis_header, &vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(vec![]).rlp_bytes(); + Block:: +} +*/ \ No newline at end of file diff --git a/src/blockchain.rs b/src/blockchain.rs index 048159b08..be2b8ce68 100644 --- a/src/blockchain.rs +++ b/src/blockchain.rs @@ -33,7 +33,7 @@ pub struct CacheSize { /// Information about best block gathered together struct BestBlock { pub hash: H256, - pub number: U256, + pub number: usize, pub total_difficulty: U256 } @@ -41,7 +41,7 @@ impl BestBlock { fn new() -> BestBlock { BestBlock { hash: H256::new(), - number: U256::from(0), + number: 0usize, total_difficulty: U256::from(0) } } @@ -58,7 +58,7 @@ pub struct BlockChain { // extra caches block_details: RefCell>, - block_hashes: RefCell>, + block_hashes: RefCell>, transaction_addresses: RefCell>, block_logs: RefCell>, blocks_blooms: RefCell>, @@ -92,7 +92,7 @@ impl BlockChain { /// let genesis_hash = "d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"; /// assert_eq!(bc.genesis_hash(), H256::from_str(genesis_hash).unwrap()); /// assert!(bc.is_known(&bc.genesis_hash())); - /// assert_eq!(bc.genesis_hash(), bc.block_hash(&U256::from(0u8)).unwrap()); + /// assert_eq!(bc.genesis_hash(), bc.block_hash(0).unwrap()); /// } /// ``` pub fn new(genesis: &[u8], path: &Path) -> BlockChain { @@ -336,9 +336,9 @@ impl BlockChain { // it is a fork i if i > 1 => { let ancestor_number = self.block_number(&route.ancestor).unwrap(); - let start_number = ancestor_number + U256::from(1u8); + let start_number = ancestor_number + 1; for (index, hash) in route.blocks.iter().skip(route.index).enumerate() { - batch.put_extras(&(start_number + U256::from(index as u64)), hash); + batch.put_extras(&(start_number + index), hash); } }, // route.blocks.len() could be 0 only if inserted block is best block, @@ -371,7 +371,7 @@ impl BlockChain { /// Returns reference to genesis hash. pub fn genesis_hash(&self) -> H256 { - self.block_hash(&U256::from(0u8)).expect("Genesis hash should always exist") + self.block_hash(0).expect("Genesis hash should always exist") } /// Get the partial-header of a block. @@ -409,8 +409,8 @@ impl BlockChain { } /// Get the hash of given block's number. - pub fn block_hash(&self, hash: &U256) -> Option { - self.query_extras(hash, &self.block_hashes) + pub fn block_hash(&self, index: usize) -> Option { + self.query_extras(&index, &self.block_hashes) } /// Get best block hash. @@ -419,7 +419,7 @@ impl BlockChain { } /// Get best block number. - pub fn best_block_number(&self) -> U256 { + pub fn best_block_number(&self) -> usize { self.best_block.borrow().number } @@ -429,7 +429,7 @@ impl BlockChain { } /// Get the number of given block's hash. - pub fn block_number(&self, hash: &H256) -> Option { + pub fn block_number(&self, hash: &H256) -> Option { self.block(hash).map(|bytes| BlockView::new(&bytes).header_view().number()) } @@ -520,7 +520,6 @@ mod tests { use std::str::FromStr; use rustc_serialize::hex::FromHex; use util::hash::*; - use util::uint::*; use blockchain::*; #[test] @@ -535,10 +534,10 @@ mod tests { let genesis_hash = H256::from_str("3caa2203f3d7c136c0295ed128a7d31cea520b1ca5e27afe17d0853331798942").unwrap(); assert_eq!(bc.genesis_hash(), genesis_hash.clone()); - assert_eq!(bc.best_block_number(), U256::from(0u8)); + assert_eq!(bc.best_block_number(), 0); assert_eq!(bc.best_block_hash(), genesis_hash.clone()); - assert_eq!(bc.block_hash(&U256::from(0u8)), Some(genesis_hash.clone())); - assert_eq!(bc.block_hash(&U256::from(1u8)), None); + assert_eq!(bc.block_hash(0), Some(genesis_hash.clone())); + assert_eq!(bc.block_hash(1), None); let first = "f90285f90219a03caa2203f3d7c136c0295ed128a7d31cea520b1ca5e27afe17d0853331798942a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0bac6177a79e910c98d86ec31a09ae37ac2de15b754fd7bed1ba52362c49416bfa0d45893a296c1490a978e0bd321b5f2635d8280365c1fe9f693d65f233e791344a0c7778a7376099ee2e5c455791c1885b5c361b95713fddcbe32d97fd01334d296b90100000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000400000000000000000000000000000000000000000000000000000008302000001832fefd882560b845627cb99a00102030405060708091011121314151617181920212223242526272829303132a08ccb2837fb2923bd97e8f2d08ea32012d6e34be018c73e49a0f98843e8f47d5d88e53be49fec01012ef866f864800a82c35094095e7baea6a6c7c4c2dfeb977efac326af552d8785012a05f200801ba0cb088b8d2ff76a7b2c6616c9d02fb6b7a501afbf8b69d7180b09928a1b80b5e4a06448fe7476c606582039bb72a9f6f4b4fad18507b8dfbd00eebbe151cc573cd2c0".from_hex().unwrap(); @@ -547,13 +546,13 @@ mod tests { let first_hash = H256::from_str("a940e5af7d146b3b917c953a82e1966b906dace3a4e355b5b0a4560190357ea1").unwrap(); - assert_eq!(bc.block_hash(&U256::from(0u8)), Some(genesis_hash.clone())); - assert_eq!(bc.best_block_number(), U256::from(1u8)); + assert_eq!(bc.block_hash(0), Some(genesis_hash.clone())); + assert_eq!(bc.best_block_number(), 1); assert_eq!(bc.best_block_hash(), first_hash.clone()); - assert_eq!(bc.block_hash(&U256::from(1u8)), Some(first_hash.clone())); + assert_eq!(bc.block_hash(1), Some(first_hash.clone())); assert_eq!(bc.block_details(&first_hash).unwrap().parent, genesis_hash.clone()); assert_eq!(bc.block_details(&genesis_hash).unwrap().children, vec![first_hash.clone()]); - assert_eq!(bc.block_hash(&U256::from(2u8)), None); + assert_eq!(bc.block_hash(2), None); } #[test] @@ -583,16 +582,16 @@ mod tests { bc.insert_block(&b3b); assert_eq!(bc.best_block_hash(), best_block_hash); - assert_eq!(bc.block_number(&genesis_hash).unwrap(), U256::from(0)); - assert_eq!(bc.block_number(&b1_hash).unwrap(), U256::from(1)); - assert_eq!(bc.block_number(&b2_hash).unwrap(), U256::from(2)); - assert_eq!(bc.block_number(&b3a_hash).unwrap(), U256::from(3)); - assert_eq!(bc.block_number(&b3b_hash).unwrap(), U256::from(3)); + assert_eq!(bc.block_number(&genesis_hash).unwrap(), 0); + assert_eq!(bc.block_number(&b1_hash).unwrap(), 1); + assert_eq!(bc.block_number(&b2_hash).unwrap(), 2); + assert_eq!(bc.block_number(&b3a_hash).unwrap(), 3); + assert_eq!(bc.block_number(&b3b_hash).unwrap(), 3); - assert_eq!(bc.block_hash(&U256::from(0)).unwrap(), genesis_hash); - assert_eq!(bc.block_hash(&U256::from(1)).unwrap(), b1_hash); - assert_eq!(bc.block_hash(&U256::from(2)).unwrap(), b2_hash); - assert_eq!(bc.block_hash(&U256::from(3)).unwrap(), b3a_hash); + assert_eq!(bc.block_hash(0).unwrap(), genesis_hash); + assert_eq!(bc.block_hash(1).unwrap(), b1_hash); + assert_eq!(bc.block_hash(2).unwrap(), b2_hash); + assert_eq!(bc.block_hash(3).unwrap(), b3a_hash); // test trie route let r0_1 = bc.tree_route(genesis_hash.clone(), b1_hash.clone()); diff --git a/src/env_info.rs b/src/env_info.rs index e7c8ae261..2ec096083 100644 --- a/src/env_info.rs +++ b/src/env_info.rs @@ -11,7 +11,7 @@ pub struct EnvInfo { /// The block author. pub author: Address, /// The block timestamp. - pub timestamp: usize, + pub timestamp: u64, /// The block difficulty. pub difficulty: U256, /// The block gas limit. diff --git a/src/ethereum/ethash.rs b/src/ethereum/ethash.rs index 1c955a91f..828441fd6 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -18,6 +18,13 @@ impl Ethash { impl Engine for Ethash { fn name(&self) -> &str { "Ethash" } fn version(&self) -> SemanticVersion { SemanticVersion::new(1, 0, 0) } + // Two fields - mix + fn seal_fields(&self) -> usize { 2 } + // Two empty data items in RLP. + fn seal_rlp(&self) -> Bytes { encode(&H64::new()) } + + /// Additional engine-specific information for the user/developer concerning `header`. + fn extra_info(&self, _header: &Header) -> HashMap { HashMap::new() } fn spec(&self) -> &Spec { &self.spec } fn evm_schedule(&self, _env_info: &EnvInfo) -> EvmSchedule { EvmSchedule::new_frontier() } @@ -45,7 +52,8 @@ fn on_close_block() { let genesis_header = engine.spec().genesis_header(); let mut db = OverlayDB::new_temp(); engine.spec().ensure_db_good(&mut db); - let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]); + let last_hashes = vec![genesis_header.hash()]; + let b = OpenBlock::new(engine.deref(), db, &genesis_header, &last_hashes, Address::zero(), vec![]); let b = b.close(); assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244f40000").unwrap()); -} \ No newline at end of file +} diff --git a/src/extras.rs b/src/extras.rs index 39ce814c8..e94aa809f 100644 --- a/src/extras.rs +++ b/src/extras.rs @@ -74,6 +74,13 @@ impl ExtrasSliceConvertable for U256 { } } +// NICE: make less horrible. +impl ExtrasSliceConvertable for usize { + fn to_extras_slice(&self, i: ExtrasIndex) -> H264 { + U256::from(*self).to_extras_slice(i) + } +} + /// Types implementing this trait can be indexed in extras database pub trait ExtrasIndexable { fn extras_index() -> ExtrasIndex; @@ -88,7 +95,7 @@ impl ExtrasIndexable for H256 { /// Familial details concerning a block #[derive(Debug, Clone)] pub struct BlockDetails { - pub number: U256, + pub number: usize, pub total_difficulty: U256, pub parent: H256, pub children: Vec diff --git a/src/header.rs b/src/header.rs index b90538009..74ef169c0 100644 --- a/src/header.rs +++ b/src/header.rs @@ -1,5 +1,6 @@ use util::*; use basic_types::*; +use time::now_utc; /// A block header. /// @@ -11,7 +12,7 @@ use basic_types::*; pub struct Header { // TODO: make all private. pub parent_hash: H256, - pub timestamp: usize, + pub timestamp: u64, pub number: usize, pub author: Address, @@ -61,15 +62,23 @@ impl Header { } } - pub fn author(&self) -> &Address { &self.author } - pub fn extra_data(&self) -> &Bytes { &self.extra_data } - pub fn seal(&self) -> &Vec { &self.seal } pub fn number(&self) -> usize { self.number } + pub fn timestamp(&self) -> u64 { self.timestamp } + pub fn author(&self) -> &Address { &self.author } + + pub fn extra_data(&self) -> &Bytes { &self.extra_data } + + pub fn seal(&self) -> &Vec { &self.seal } // TODO: seal_at, set_seal_at &c. + pub fn set_number(&mut self, a: usize) { self.number = a; self.note_dirty(); } + pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); } + pub fn set_timestamp_now(&mut self) { self.timestamp = now_utc().to_timespec().sec as u64; self.note_dirty(); } pub fn set_author(&mut self, a: Address) { if a != self.author { self.author = a; self.note_dirty(); } } + pub fn set_extra_data(&mut self, a: Bytes) { if a != self.extra_data { self.extra_data = a; self.note_dirty(); } } + pub fn set_seal(&mut self, a: Vec) { self.seal = a; self.note_dirty(); } /// Get the hash of this header (sha3 of the RLP). diff --git a/src/lib.rs b/src/lib.rs index 0227d5e25..c8695b89d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -78,6 +78,7 @@ extern crate flate2; extern crate rocksdb; extern crate heapsize; extern crate crypto; +extern crate time; extern crate env_logger; #[cfg(feature = "jit" )] diff --git a/src/spec.rs b/src/spec.rs index 2ba1fa10c..c106169fe 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -60,7 +60,7 @@ pub struct Spec { pub difficulty: U256, pub gas_limit: U256, pub gas_used: U256, - pub timestamp: usize, + pub timestamp: u64, pub extra_data: Bytes, pub genesis_state: HashMap, pub seal_fields: usize, @@ -181,7 +181,7 @@ impl Spec { difficulty: U256::from_str(&genesis["difficulty"].as_string().unwrap()[2..]).unwrap(), gas_limit: U256::from_str(&genesis["gasLimit"].as_string().unwrap()[2..]).unwrap(), gas_used: U256::from(0u8), - timestamp: usize::from_str(&genesis["timestamp"].as_string().unwrap()[2..]).unwrap(), + timestamp: u64::from_str(&genesis["timestamp"].as_string().unwrap()[2..]).unwrap(), extra_data: genesis["extraData"].as_string().unwrap()[2..].from_hex().unwrap(), genesis_state: state, seal_fields: seal_fields, diff --git a/src/views.rs b/src/views.rs index e66a46178..3d576b5ce 100644 --- a/src/views.rs +++ b/src/views.rs @@ -113,7 +113,7 @@ impl<'a> HeaderView<'a> { pub fn difficulty(&self) -> U256 { self.rlp.val_at(7) } /// Returns block number. - pub fn number(&self) -> U256 { self.rlp.val_at(8) } + pub fn number(&self) -> usize { self.rlp.val_at(8) } /// Returns block gas limit. pub fn gas_limit(&self) -> U256 { self.rlp.val_at(9) } @@ -122,7 +122,7 @@ impl<'a> HeaderView<'a> { pub fn gas_used(&self) -> U256 { self.rlp.val_at(10) } /// Returns timestamp. - pub fn timestamp(&self) -> U256 { self.rlp.val_at(11) } + pub fn timestamp(&self) -> usize { self.rlp.val_at(11) } /// Returns block extra data. pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) } From abb4975400b305a60c4c22e88130ef3f93e0b980 Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Sun, 10 Jan 2016 22:57:31 +0100 Subject: [PATCH 5/9] Set timestamp in enactment. --- src/block.rs | 1 + src/views.rs | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/block.rs b/src/block.rs index 0794fcfc5..16ec3b7f5 100644 --- a/src/block.rs +++ b/src/block.rs @@ -250,6 +250,7 @@ pub fn enacted(rlp_bytes: &[u8], db: OverlayDB, engine: &Engine, parent: &Header let block = BlockView::new(rlp_bytes); let header = block.header_view(); let mut b = OpenBlock::new(engine, db, parent, last_hashes, header.author(), header.extra_data()); + b.set_timestamp(header.timestamp()); for t in block.transactions().into_iter() { try!(b.push_transaction(t, None)); } for u in block.uncles().into_iter() { try!(b.push_uncle(u)); } Ok(try!(b.close().seal(header.seal()))) diff --git a/src/views.rs b/src/views.rs index 3d576b5ce..8e202d0b7 100644 --- a/src/views.rs +++ b/src/views.rs @@ -122,7 +122,7 @@ impl<'a> HeaderView<'a> { pub fn gas_used(&self) -> U256 { self.rlp.val_at(10) } /// Returns timestamp. - pub fn timestamp(&self) -> usize { self.rlp.val_at(11) } + pub fn timestamp(&self) -> u64 { self.rlp.val_at(11) } /// Returns block extra data. pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) } From 4512322d3ecaf8242c56dab343d394b2584a2d03 Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Sun, 10 Jan 2016 23:10:06 +0100 Subject: [PATCH 6/9] Block enactment with test. --- src/block.rs | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/src/block.rs b/src/block.rs index 16ec3b7f5..941cef985 100644 --- a/src/block.rs +++ b/src/block.rs @@ -239,14 +239,17 @@ impl SealedBlock { for e in self.block.archive.iter() { e.transaction.rlp_append(&mut block_rlp); } block_rlp.append_raw(&self.uncle_bytes, 1); block_rlp.out() - } + } + + /// Drop this object and return the underlieing database. + pub fn drain(self) -> OverlayDB { self.block.state.drop().1 } } impl IsBlock for SealedBlock { fn block(&self) -> &Block { &self.block } } -pub fn enacted(rlp_bytes: &[u8], db: OverlayDB, engine: &Engine, parent: &Header, last_hashes: &LastHashes) -> Result { +pub fn enact(rlp_bytes: &[u8], engine: &Engine, db: OverlayDB, parent: &Header, last_hashes: &LastHashes) -> Result { let block = BlockView::new(rlp_bytes); let header = block.header_view(); let mut b = OpenBlock::new(engine, db, parent, last_hashes, header.author(), header.extra_data()); @@ -268,16 +271,25 @@ fn open_block() { let b = b.close(); let _ = b.seal(vec![]); } -/* + #[test] fn enact_block() { use spec::*; let engine = Spec::new_test().to_engine().unwrap(); let genesis_header = engine.spec().genesis_header(); + let mut db = OverlayDB::new_temp(); engine.spec().ensure_db_good(&mut db); + let b = OpenBlock::new(engine.deref(), db, &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 b = OpenBlock::new(engine.deref(), db, &genesis_header, &vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(vec![]).rlp_bytes(); - Block:: + let mut db = OverlayDB::new_temp(); + engine.spec().ensure_db_good(&mut db); + let e = enact(&orig_bytes, engine.deref(), db, &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()); } -*/ \ No newline at end of file From 452294ab8dc2882be0773b01f4355992f63a4682 Mon Sep 17 00:00:00 2001 From: arkpar Date: Sun, 10 Jan 2016 23:37:09 +0100 Subject: [PATCH 7/9] ImportResult becomes a result --- src/blockchain.rs | 35 ++++++++++++++----------- src/client.rs | 30 +++++---------------- src/error.rs | 7 +++++ src/queue.rs | 22 +++++++--------- src/sync/chain.rs | 66 ++++++++++++++++++++++++++--------------------- src/sync/io.rs | 9 +++++++ src/sync/tests.rs | 12 ++++----- 7 files changed, 96 insertions(+), 85 deletions(-) diff --git a/src/blockchain.rs b/src/blockchain.rs index 3a1d24725..c6539e423 100644 --- a/src/blockchain.rs +++ b/src/blockchain.rs @@ -200,11 +200,16 @@ impl BlockChain { /// ```json /// { blocks: [B4, B3, A3, A4], ancestor: A2, index: 2 } /// ``` - pub fn tree_route(&self, from: H256, to: H256) -> TreeRoute { - let from_details = self.block_details(&from).expect("from hash is invalid!"); - let to_details = self.block_details(&to).expect("to hash is invalid!"); - - self._tree_route((from_details, from), (to_details, to)) + pub fn tree_route(&self, from: H256, to: H256) -> Option { + let from_details = match self.block_details(&from) { + Some(h) => h, + None => return None, + }; + let to_details = match self.block_details(&to) { + Some(h) => h, + None => return None, + }; + Some(self._tree_route((from_details, from), (to_details, to))) } /// Similar to `tree_route` function, but can be used to return a route @@ -597,52 +602,52 @@ mod tests { assert_eq!(bc.block_hash(&U256::from(3)).unwrap(), b3a_hash); // test trie route - let r0_1 = bc.tree_route(genesis_hash.clone(), b1_hash.clone()); + let r0_1 = bc.tree_route(genesis_hash.clone(), b1_hash.clone()).unwrap(); assert_eq!(r0_1.ancestor, genesis_hash); assert_eq!(r0_1.blocks, [b1_hash.clone()]); assert_eq!(r0_1.index, 0); - let r0_2 = bc.tree_route(genesis_hash.clone(), b2_hash.clone()); + let r0_2 = bc.tree_route(genesis_hash.clone(), b2_hash.clone()).unwrap(); assert_eq!(r0_2.ancestor, genesis_hash); assert_eq!(r0_2.blocks, [b1_hash.clone(), b2_hash.clone()]); assert_eq!(r0_2.index, 0); - let r1_3a = bc.tree_route(b1_hash.clone(), b3a_hash.clone()); + let r1_3a = bc.tree_route(b1_hash.clone(), b3a_hash.clone()).unwrap(); assert_eq!(r1_3a.ancestor, b1_hash); assert_eq!(r1_3a.blocks, [b2_hash.clone(), b3a_hash.clone()]); assert_eq!(r1_3a.index, 0); - let r1_3b = bc.tree_route(b1_hash.clone(), b3b_hash.clone()); + let r1_3b = bc.tree_route(b1_hash.clone(), b3b_hash.clone()).unwrap(); assert_eq!(r1_3b.ancestor, b1_hash); assert_eq!(r1_3b.blocks, [b2_hash.clone(), b3b_hash.clone()]); assert_eq!(r1_3b.index, 0); - let r3a_3b = bc.tree_route(b3a_hash.clone(), b3b_hash.clone()); + let r3a_3b = bc.tree_route(b3a_hash.clone(), b3b_hash.clone()).unwrap(); assert_eq!(r3a_3b.ancestor, b2_hash); assert_eq!(r3a_3b.blocks, [b3a_hash.clone(), b3b_hash.clone()]); assert_eq!(r3a_3b.index, 1); - let r1_0 = bc.tree_route(b1_hash.clone(), genesis_hash.clone()); + let r1_0 = bc.tree_route(b1_hash.clone(), genesis_hash.clone()).unwrap(); assert_eq!(r1_0.ancestor, genesis_hash); assert_eq!(r1_0.blocks, [b1_hash.clone()]); assert_eq!(r1_0.index, 1); - let r2_0 = bc.tree_route(b2_hash.clone(), genesis_hash.clone()); + let r2_0 = bc.tree_route(b2_hash.clone(), genesis_hash.clone()).unwrap(); assert_eq!(r2_0.ancestor, genesis_hash); assert_eq!(r2_0.blocks, [b2_hash.clone(), b1_hash.clone()]); assert_eq!(r2_0.index, 2); - let r3a_1 = bc.tree_route(b3a_hash.clone(), b1_hash.clone()); + let r3a_1 = bc.tree_route(b3a_hash.clone(), b1_hash.clone()).unwrap(); assert_eq!(r3a_1.ancestor, b1_hash); assert_eq!(r3a_1.blocks, [b3a_hash.clone(), b2_hash.clone()]); assert_eq!(r3a_1.index, 2); - let r3b_1 = bc.tree_route(b3b_hash.clone(), b1_hash.clone()); + let r3b_1 = bc.tree_route(b3b_hash.clone(), b1_hash.clone()).unwrap(); assert_eq!(r3b_1.ancestor, b1_hash); assert_eq!(r3b_1.blocks, [b3b_hash.clone(), b2_hash.clone()]); assert_eq!(r3b_1.index, 2); - let r3b_3a = bc.tree_route(b3b_hash.clone(), b3a_hash.clone()); + let r3b_3a = bc.tree_route(b3b_hash.clone(), b3a_hash.clone()).unwrap(); assert_eq!(r3b_3a.ancestor, b2_hash); assert_eq!(r3b_3a.blocks, [b3b_hash.clone(), b3a_hash.clone()]); assert_eq!(r3b_3a.index, 1); diff --git a/src/client.rs b/src/client.rs index e9d0b1485..88c828af8 100644 --- a/src/client.rs +++ b/src/client.rs @@ -2,21 +2,14 @@ use std::sync::Arc; use util::*; use blockchain::BlockChain; use views::BlockView; - -/// Status for a block in a queue. -pub enum QueueStatus { - /// Part of the known chain. - Known, - /// Part of the unknown chain. - Unknown, -} +use error::ImportError; /// General block status pub enum BlockStatus { /// Part of the blockchain. InChain, /// Queued for import. - Queued(QueueStatus), + Queued, /// Known as bad. Bad, /// Unknown. @@ -24,16 +17,7 @@ pub enum BlockStatus { } /// Result of import block operation. -pub enum ImportResult { - /// Added to import queue. - Queued(QueueStatus), - /// Already in the chain. - AlreadyInChain, - /// Already queued for import. - AlreadyQueued(QueueStatus), - /// Bad or already known as bad. - Bad, -} +pub type ImportResult = Result<(), ImportError>; /// Information about the blockchain gthered together. pub struct BlockChainInfo { @@ -88,7 +72,7 @@ pub trait BlockChainClient : Sync { /// Get a tree route between `from` and `to`. /// See `BlockChain::tree_route`. - fn tree_route(&self, from: &H256, to: &H256) -> TreeRoute; + fn tree_route(&self, from: &H256, to: &H256) -> Option; /// Get latest state node fn state_data(&self, hash: &H256) -> Option; @@ -165,7 +149,7 @@ impl BlockChainClient for Client { } } - fn tree_route(&self, from: &H256, to: &H256) -> TreeRoute { + fn tree_route(&self, from: &H256, to: &H256) -> Option { self.chain.tree_route(from.clone(), to.clone()) } @@ -184,11 +168,11 @@ impl BlockChainClient for Client { let header = block.header_view(); let hash = header.sha3(); if self.chain.is_known(&hash) { - return ImportResult::Bad; + return Err(ImportError::AlreadyInChain); } } self.chain.insert_block(bytes); - ImportResult::Queued(QueueStatus::Known) + Ok(()) } fn queue_status(&self) -> BlockQueueStatus { diff --git a/src/error.rs b/src/error.rs index 68b75ab5b..d975f15b6 100644 --- a/src/error.rs +++ b/src/error.rs @@ -23,6 +23,13 @@ pub enum BlockError { InvalidSealArity(Mismatch), } +#[derive(Debug)] +pub enum ImportError { + Bad(BlockError), + AlreadyInChain, + AlreadyQueued, +} + #[derive(Debug)] /// General error type which should be capable of representing all errors in ethcore. pub enum Error { diff --git a/src/queue.rs b/src/queue.rs index 8d427e8a1..ea212aaf1 100644 --- a/src/queue.rs +++ b/src/queue.rs @@ -1,26 +1,24 @@ use std::sync::Arc; -//use util::bytes::*; -use util::sha3::*; +use util::*; use blockchain::BlockChain; use client::{QueueStatus, ImportResult}; use views::{BlockView}; - -pub struct BlockQueue { - chain: Arc -} +/// A queue of blocks. Sits between network or other I/O and the BlockChain. +/// Sorts them ready for blockchain insertion. +pub struct BlockQueue; impl BlockQueue { - pub fn new(chain: Arc) -> BlockQueue { - BlockQueue { - chain: chain - } + /// Creates a new queue instance. + pub fn new() -> BlockQueue { } + /// Clear the queue and stop verification activity. pub fn clear(&mut self) { } - pub fn import_block(&mut self, bytes: &[u8]) -> ImportResult { + /// Add a block to the queue. + pub fn import_block(&mut self, bytes: &[u8], bc: &mut BlockChain) -> ImportResult { //TODO: verify block { let block = BlockView::new(bytes); @@ -30,7 +28,7 @@ impl BlockQueue { return ImportResult::Bad; } } - self.chain.insert_block(bytes); + bc.insert_block(bytes); ImportResult::Queued(QueueStatus::Known) } } diff --git a/src/sync/chain.rs b/src/sync/chain.rs index bfbf3cfb8..8ef9649b4 100644 --- a/src/sync/chain.rs +++ b/src/sync/chain.rs @@ -17,8 +17,9 @@ use util::*; use std::mem::{replace}; use views::{HeaderView}; use header::{Header as BlockHeader}; -use client::{BlockNumber, BlockChainClient, BlockStatus, QueueStatus, ImportResult}; +use client::{BlockNumber, BlockChainClient, BlockStatus}; use sync::range_collection::{RangeCollection, ToUsize, FromUsize}; +use error::*; use sync::io::SyncIo; impl ToUsize for BlockNumber { @@ -76,12 +77,13 @@ struct HeaderId { } #[derive(Copy, Clone, Eq, PartialEq, Debug)] +/// Sync state pub enum SyncState { /// Initial chain sync has not started yet NotSynced, /// Initial chain sync complete. Waiting for new packets Idle, - /// Block downloading paused. Waiting for block queue to process blocks and free space + /// Block downloading paused. Waiting for block queue to process blocks and free some space Waiting, /// Downloading blocks Blocks, @@ -108,24 +110,33 @@ pub struct SyncStatus { } #[derive(PartialEq, Eq, Debug)] +/// Peer data type requested enum PeerAsking { Nothing, BlockHeaders, BlockBodies, } +/// Syncing peer information struct PeerInfo { + /// eth protocol version protocol_version: u32, + /// Peer chain genesis hash genesis: H256, + /// Peer network id network_id: U256, + /// Peer best block hash latest: H256, + /// Peer total difficulty difficulty: U256, + /// Type of data currenty being requested from peer. asking: PeerAsking, + /// A set of block numbers being requested asking_blocks: Vec, } -type Body = Bytes; - +/// Blockchain sync handler. +/// See module documentation for more details. pub struct ChainSync { /// Sync state state: SyncState, @@ -140,7 +151,7 @@ pub struct ChainSync { /// Downloaded headers. headers: Vec<(BlockNumber, Vec
)>, //TODO: use BTreeMap once range API is sable. For now it is a vector sorted in descending order /// Downloaded bodies - bodies: Vec<(BlockNumber, Vec)>, //TODO: use BTreeMap once range API is sable. For now it is a vector sorted in descending order + bodies: Vec<(BlockNumber, Vec)>, //TODO: use BTreeMap once range API is sable. For now it is a vector sorted in descending order /// Peer info peers: HashMap, /// Used to map body to header @@ -390,31 +401,31 @@ impl ChainSync { // TODO: Decompose block and add to self.headers and self.bodies instead if header_view.number() == From::from(self.last_imported_block + 1) { match io.chain().import_block(block_rlp.as_raw()) { - ImportResult::AlreadyInChain => { + Err(ImportError::AlreadyInChain) => { trace!(target: "sync", "New block already in chain {:?}", h); }, - ImportResult::AlreadyQueued(_) => { + Err(ImportError::AlreadyQueued) => { trace!(target: "sync", "New block already queued {:?}", h); }, - ImportResult::Queued(QueueStatus::Known) => { + Ok(()) => { trace!(target: "sync", "New block queued {:?}", h); }, - ImportResult::Queued(QueueStatus::Unknown) => { - trace!(target: "sync", "New block unknown {:?}", h); - //TODO: handle too many unknown blocks - let difficulty: U256 = try!(r.val_at(1)); - let peer_difficulty = self.peers.get_mut(&peer_id).expect("ChainSync: unknown peer").difficulty; - if difficulty > peer_difficulty { - trace!(target: "sync", "Received block {:?} with no known parent. Peer needs syncing...", h); - self.sync_peer(io, peer_id, true); - } - }, - ImportResult::Bad =>{ - debug!(target: "sync", "Bad new block {:?}", h); + Err(e) => { + debug!(target: "sync", "Bad new block {:?} : {:?}", h, e); io.disable_peer(peer_id); } }; } + else { + trace!(target: "sync", "New block unknown {:?}", h); + //TODO: handle too many unknown blocks + let difficulty: U256 = try!(r.val_at(1)); + let peer_difficulty = self.peers.get_mut(&peer_id).expect("ChainSync: unknown peer").difficulty; + if difficulty > peer_difficulty { + trace!(target: "sync", "Received block {:?} with no known parent. Peer needs syncing...", h); + self.sync_peer(io, peer_id, true); + } + } Ok(()) } @@ -434,7 +445,7 @@ impl ChainSync { BlockStatus::InChain => { trace!(target: "sync", "New block hash already in chain {:?}", h); }, - BlockStatus::Queued(_) => { + BlockStatus::Queued => { trace!(target: "sync", "New hash block already queued {:?}", h); }, BlockStatus::Unknown => { @@ -642,27 +653,24 @@ impl ChainSync { block_rlp.append_raw(body.at(1).as_raw(), 1); let h = &headers.1[i].hash; match io.chain().import_block(&block_rlp.out()) { - ImportResult::AlreadyInChain => { + Err(ImportError::AlreadyInChain) => { trace!(target: "sync", "Block already in chain {:?}", h); self.last_imported_block = headers.0 + i as BlockNumber; self.last_imported_hash = h.clone(); }, - ImportResult::AlreadyQueued(_) => { + Err(ImportError::AlreadyQueued) => { trace!(target: "sync", "Block already queued {:?}", h); self.last_imported_block = headers.0 + i as BlockNumber; self.last_imported_hash = h.clone(); }, - ImportResult::Queued(QueueStatus::Known) => { + Ok(()) => { trace!(target: "sync", "Block queued {:?}", h); self.last_imported_block = headers.0 + i as BlockNumber; self.last_imported_hash = h.clone(); imported += 1; }, - ImportResult::Queued(QueueStatus::Unknown) => { - panic!("Queued out of order block"); - }, - ImportResult::Bad =>{ - debug!(target: "sync", "Bad block {:?}", h); + Err(e) => { + debug!(target: "sync", "Bad block {:?} : {:?}", h, e); restart = true; } } diff --git a/src/sync/io.rs b/src/sync/io.rs index ed7b0fec5..9806a3bf5 100644 --- a/src/sync/io.rs +++ b/src/sync/io.rs @@ -2,19 +2,28 @@ use client::BlockChainClient; use util::network::{HandlerIo, PeerId, PacketId,}; use util::error::UtilError; +/// IO interface for the syning handler. +/// Provides peer connection management and an interface to the blockchain client. +// TODO: ratings pub trait SyncIo { + /// Disable a peer fn disable_peer(&mut self, peer_id: &PeerId); + /// Respond to current request with a packet. Can be called from an IO handler for incoming packet. fn respond(&mut self, packet_id: PacketId, data: Vec) -> Result<(), UtilError>; + /// Send a packet to a peer. fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec) -> Result<(), UtilError>; + /// Get the blockchain fn chain<'s>(&'s mut self) -> &'s mut BlockChainClient; } +/// Wraps `HandlerIo` and the blockchain client pub struct NetSyncIo<'s, 'h> where 'h:'s { network: &'s mut HandlerIo<'h>, chain: &'s mut BlockChainClient } impl<'s, 'h> NetSyncIo<'s, 'h> { + /// Creates a new instance from the `HandlerIo` and the blockchain client reference. pub fn new(network: &'s mut HandlerIo<'h>, chain: &'s mut BlockChainClient) -> NetSyncIo<'s,'h> { NetSyncIo { network: network, diff --git a/src/sync/tests.rs b/src/sync/tests.rs index dfcf75c8b..b284a568e 100644 --- a/src/sync/tests.rs +++ b/src/sync/tests.rs @@ -6,7 +6,7 @@ use util::sha3::Hashable; use util::rlp::{self, Rlp, RlpStream, View, Stream}; use util::network::{PeerId, PacketId}; use util::error::UtilError; -use client::{BlockChainClient, BlockStatus, BlockNumber, TreeRoute, BlockQueueStatus, BlockChainInfo, ImportResult, QueueStatus}; +use client::{BlockChainClient, BlockStatus, BlockNumber, TreeRoute, BlockQueueStatus, BlockChainInfo, ImportResult}; use header::Header as BlockHeader; use sync::io::SyncIo; use sync::chain::ChainSync; @@ -49,7 +49,7 @@ impl TestBlockChainClient { rlp.append(&header); rlp.append_raw(&rlp::NULL_RLP, 1); rlp.append_raw(uncles.as_raw(), 1); - self.import_block(rlp.as_raw()); + self.import_block(rlp.as_raw()).unwrap(); } } } @@ -100,12 +100,12 @@ impl BlockChainClient for TestBlockChainClient { } } - fn tree_route(&self, _from: &H256, _to: &H256) -> TreeRoute { - TreeRoute { + fn tree_route(&self, _from: &H256, _to: &H256) -> Option { + Some(TreeRoute { blocks: Vec::new(), ancestor: H256::new(), index: 0 - } + }) } fn state_data(&self, _h: &H256) -> Option { @@ -153,7 +153,7 @@ impl BlockChainClient for TestBlockChainClient { else { self.blocks.insert(header.hash(), b.to_vec()); } - ImportResult::Queued(QueueStatus::Known) + Ok(()) } fn queue_status(&self) -> BlockQueueStatus { From 33d3a4d6339d258e753fcf9c2a2d0a7163e8b7b1 Mon Sep 17 00:00:00 2001 From: arkpar Date: Mon, 11 Jan 2016 11:51:31 +0100 Subject: [PATCH 8/9] Engine and Spec are now thread safe --- | 0 src/bin/client.rs | 5 +++-- src/blockchain.rs | 1 - src/builtin.rs | 5 +++++ src/client.rs | 8 +++++--- src/engine.rs | 2 +- src/ethereum/ethash.rs | 4 ++++ src/ethereum/mod.rs | 6 +++--- src/spec.rs | 41 +++++++++++++++++++++++++++++++---------- src/sync/mod.rs | 5 +++-- 10 files changed, 55 insertions(+), 22 deletions(-) create mode 100644 diff --git a/ b/ new file mode 100644 index 000000000..e69de29bb diff --git a/src/bin/client.rs b/src/bin/client.rs index 09e414476..f8b29ac1c 100644 --- a/src/bin/client.rs +++ b/src/bin/client.rs @@ -11,15 +11,16 @@ use util::network::{NetworkService}; use ethcore::client::Client; use ethcore::sync::EthSync; use ethcore::ethereum; +use ethcore::ethereum::ethash::Ethash; fn main() { ::env_logger::init().ok(); let mut service = NetworkService::start().unwrap(); //TODO: replace with proper genesis and chain params. - let frontier = ethereum::new_frontier(); + let engine = Ethash::new_arc(ethereum::new_frontier()); let mut dir = env::temp_dir(); dir.push(H32::random().hex()); - let client = Arc::new(Client::new(&frontier.genesis_block(), &dir)); + let client = Arc::new(Client::new(engine, &dir)); EthSync::register(&mut service, client); loop { let mut cmd = String::new(); diff --git a/src/blockchain.rs b/src/blockchain.rs index 59a82858e..c102ba1b4 100644 --- a/src/blockchain.rs +++ b/src/blockchain.rs @@ -1,6 +1,5 @@ //! Fast access to blockchain data. -use std::sync::*; use util::*; use rocksdb::{DB, WriteBatch, Writable}; use header::*; diff --git a/src/builtin.rs b/src/builtin.rs index 309b8f3e5..0c1e60d5f 100644 --- a/src/builtin.rs +++ b/src/builtin.rs @@ -12,6 +12,11 @@ pub struct Builtin { pub execute: Box, } +// Rust does not mark closurer that do not capture as Sync +// We promise that all builtins are thread safe since they only operate on given input. +unsafe impl Sync for Builtin {} +unsafe impl Send for Builtin {} + impl fmt::Debug for Builtin { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "") diff --git a/src/client.rs b/src/client.rs index 7f92a9a4b..019bdf797 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,9 +1,9 @@ -use std::sync::Arc; use util::*; use blockchain::BlockChain; use views::BlockView; use error::ImportError; use header::BlockNumber; +use engine::Engine; /// General block status pub enum BlockStatus { @@ -95,13 +95,15 @@ pub trait BlockChainClient : Sync { /// Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue. pub struct Client { chain: Arc, + _engine: Arc, } impl Client { - pub fn new(genesis: &[u8], path: &Path) -> Client { - let chain = Arc::new(BlockChain::new(genesis, path)); + pub fn new(engine: Arc, path: &Path) -> Client { + let chain = Arc::new(BlockChain::new(&engine.spec().genesis_block(), path)); Client { chain: chain.clone(), + _engine: engine.clone(), } } } diff --git a/src/engine.rs b/src/engine.rs index bfaf46348..64f85e079 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -4,7 +4,7 @@ use spec::Spec; /// A consensus mechanism for the chain. Generally either proof-of-work or proof-of-stake-based. /// Provides hooks into each of the major parts of block import. -pub trait Engine { +pub trait Engine : Sync + Send { /// The name of this engine. fn name(&self) -> &str; /// The version of this engine. Should be of the form diff --git a/src/ethereum/ethash.rs b/src/ethereum/ethash.rs index 828441fd6..d260e21b4 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -13,6 +13,10 @@ impl Ethash { pub fn new_boxed(spec: Spec) -> Box { Box::new(Ethash{spec: spec}) } + + pub fn new_arc(spec: Spec) -> Arc { + Arc::new(Ethash{spec: spec}) + } } impl Engine for Ethash { diff --git a/src/ethereum/mod.rs b/src/ethereum/mod.rs index ed1950d64..b3efe4a3d 100644 --- a/src/ethereum/mod.rs +++ b/src/ethereum/mod.rs @@ -52,7 +52,7 @@ mod tests { fn morden() { let morden = new_morden(); - assert_eq!(*morden.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap()); + assert_eq!(morden.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap()); let genesis = morden.genesis_block(); assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap()); @@ -63,10 +63,10 @@ mod tests { fn frontier() { let frontier = new_frontier(); - assert_eq!(*frontier.state_root(), H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap()); + assert_eq!(frontier.state_root(), H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap()); let genesis = frontier.genesis_block(); assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3").unwrap()); let _ = frontier.to_engine(); } -} \ No newline at end of file +} diff --git a/src/spec.rs b/src/spec.rs index 0d821a6ad..acdfd2ecf 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -40,6 +40,27 @@ fn json_to_rlp_map(json: &Json) -> HashMap { }) } +//TODO: add code and data +#[derive(Debug)] +/// Genesis account data. Does no thave a DB overlay cache +pub struct GenesisAccount { + // Balance of the account. + balance: U256, + // Nonce of the account. + nonce: U256, +} + +impl GenesisAccount { + pub fn rlp(&self) -> Bytes { + let mut stream = RlpStream::new_list(4); + stream.append(&self.nonce); + stream.append(&self.balance); + stream.append(&SHA3_NULL_RLP); + stream.append(&SHA3_EMPTY); + stream.out() + } +} + /// Parameters for a block chain; includes both those intrinsic to the design of the /// chain and those to be interpreted by the active chain engine. #[derive(Debug)] @@ -62,12 +83,12 @@ pub struct Spec { pub gas_used: U256, pub timestamp: u64, pub extra_data: Bytes, - pub genesis_state: HashMap, + pub genesis_state: HashMap, pub seal_fields: usize, pub seal_rlp: Bytes, // May be prepopulated if we know this in advance. - state_root_memo: RefCell>, + state_root_memo: RwLock>, } impl Spec { @@ -82,11 +103,11 @@ impl Spec { } /// Return the state root for the genesis state, memoising accordingly. - pub fn state_root(&self) -> Ref { - if self.state_root_memo.borrow().is_none() { - *self.state_root_memo.borrow_mut() = Some(sec_trie_root(self.genesis_state.iter().map(|(k, v)| (k.to_vec(), v.rlp())).collect())); + pub fn state_root(&self) -> H256 { + if self.state_root_memo.read().unwrap().is_none() { + *self.state_root_memo.write().unwrap() = Some(sec_trie_root(self.genesis_state.iter().map(|(k, v)| (k.to_vec(), v.rlp())).collect())); } - Ref::map(self.state_root_memo.borrow(), |x|x.as_ref().unwrap()) + self.state_root_memo.read().unwrap().as_ref().unwrap().clone() } pub fn genesis_header(&self) -> Header { @@ -113,7 +134,7 @@ impl Spec { let r = Rlp::new(&seal); (0..self.seal_fields).map(|i| r.at(i).as_raw().to_vec()).collect() }, - hash: RefCell::new(None) + hash: RefCell::new(None), } } @@ -149,7 +170,7 @@ impl Spec { // let nonce = if let Some(&Json::String(ref n)) = acc.find("nonce") {U256::from_dec_str(n).unwrap_or(U256::from(0))} else {U256::from(0)}; // TODO: handle code & data if they exist. if balance.is_some() || nonce.is_some() { - state.insert(addr, Account::new_basic(balance.unwrap_or(U256::from(0)), nonce.unwrap_or(U256::from(0)))); + state.insert(addr, GenesisAccount { balance: balance.unwrap_or(U256::from(0)), nonce: nonce.unwrap_or(U256::from(0)) }); } } } @@ -186,7 +207,7 @@ impl Spec { genesis_state: state, seal_fields: seal_fields, seal_rlp: seal_rlp, - state_root_memo: RefCell::new(genesis.find("stateRoot").and_then(|_| genesis["stateRoot"].as_string()).map(|s| H256::from_str(&s[2..]).unwrap())), + state_root_memo: RwLock::new(genesis.find("stateRoot").and_then(|_| genesis["stateRoot"].as_string()).map(|s| H256::from_str(&s[2..]).unwrap())), } } @@ -228,7 +249,7 @@ mod tests { fn test_chain() { let test_spec = Spec::new_test(); - assert_eq!(*test_spec.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap()); + assert_eq!(test_spec.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap()); let genesis = test_spec.genesis_block(); assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap()); diff --git a/src/sync/mod.rs b/src/sync/mod.rs index a070b2d59..aca40ffba 100644 --- a/src/sync/mod.rs +++ b/src/sync/mod.rs @@ -13,12 +13,13 @@ /// use ethcore::client::Client; /// use ethcore::sync::EthSync; /// use ethcore::ethereum; +/// use ethcore::ethereum::ethash::Ethash; /// /// fn main() { /// let mut service = NetworkService::start().unwrap(); -/// let frontier = ethereum::new_frontier(); +/// let engine = Ethash::new_arc(ethereum::new_frontier()); /// let dir = env::temp_dir(); -/// let client = Arc::new(Client::new(&frontier.genesis_block(), &dir)); +/// let client = Arc::new(Client::new(engine, &dir)); /// EthSync::register(&mut service, client); /// } /// ``` From 3a2663ce932094e11f4fe3b08b83e2e375345aa5 Mon Sep 17 00:00:00 2001 From: arkpar Date: Mon, 11 Jan 2016 12:28:59 +0100 Subject: [PATCH 9/9] Client now takes Spec instead of Engine --- src/bin/client.rs | 5 ++--- src/client.rs | 16 +++++++++------- src/ethereum/ethash.rs | 4 ---- src/sync/mod.rs | 4 +--- 4 files changed, 12 insertions(+), 17 deletions(-) diff --git a/src/bin/client.rs b/src/bin/client.rs index f8b29ac1c..a644ecd1b 100644 --- a/src/bin/client.rs +++ b/src/bin/client.rs @@ -11,16 +11,15 @@ use util::network::{NetworkService}; use ethcore::client::Client; use ethcore::sync::EthSync; use ethcore::ethereum; -use ethcore::ethereum::ethash::Ethash; fn main() { ::env_logger::init().ok(); let mut service = NetworkService::start().unwrap(); //TODO: replace with proper genesis and chain params. - let engine = Ethash::new_arc(ethereum::new_frontier()); + let spec = ethereum::new_frontier(); let mut dir = env::temp_dir(); dir.push(H32::random().hex()); - let client = Arc::new(Client::new(engine, &dir)); + let client = Arc::new(Client::new(spec, &dir).unwrap()); EthSync::register(&mut service, client); loop { let mut cmd = String::new(); diff --git a/src/client.rs b/src/client.rs index 019bdf797..b914dba19 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,8 +1,9 @@ use util::*; use blockchain::BlockChain; use views::BlockView; -use error::ImportError; +use error::*; use header::BlockNumber; +use spec::Spec; use engine::Engine; /// General block status @@ -95,16 +96,17 @@ pub trait BlockChainClient : Sync { /// Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue. pub struct Client { chain: Arc, - _engine: Arc, + _engine: Arc>, } impl Client { - pub fn new(engine: Arc, path: &Path) -> Client { - let chain = Arc::new(BlockChain::new(&engine.spec().genesis_block(), path)); - Client { + pub fn new(spec: Spec, path: &Path) -> Result { + let chain = Arc::new(BlockChain::new(&spec.genesis_block(), path)); + let engine = Arc::new(try!(spec.to_engine())); + Ok(Client { chain: chain.clone(), - _engine: engine.clone(), - } + _engine: engine, + }) } } diff --git a/src/ethereum/ethash.rs b/src/ethereum/ethash.rs index d260e21b4..828441fd6 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -13,10 +13,6 @@ impl Ethash { pub fn new_boxed(spec: Spec) -> Box { Box::new(Ethash{spec: spec}) } - - pub fn new_arc(spec: Spec) -> Arc { - Arc::new(Ethash{spec: spec}) - } } impl Engine for Ethash { diff --git a/src/sync/mod.rs b/src/sync/mod.rs index aca40ffba..300465014 100644 --- a/src/sync/mod.rs +++ b/src/sync/mod.rs @@ -13,13 +13,11 @@ /// use ethcore::client::Client; /// use ethcore::sync::EthSync; /// use ethcore::ethereum; -/// use ethcore::ethereum::ethash::Ethash; /// /// fn main() { /// let mut service = NetworkService::start().unwrap(); -/// let engine = Ethash::new_arc(ethereum::new_frontier()); /// let dir = env::temp_dir(); -/// let client = Arc::new(Client::new(engine, &dir)); +/// let client = Arc::new(Client::new(ethereum::new_frontier(), &dir).unwrap()); /// EthSync::register(&mut service, client); /// } /// ```