diff --git a/ b/ new file mode 100644 index 000000000..e69de29bb 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/bin/client.rs b/src/bin/client.rs index 09e414476..a644ecd1b 100644 --- a/src/bin/client.rs +++ b/src/bin/client.rs @@ -16,10 +16,10 @@ 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 spec = 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(spec, &dir).unwrap()); EthSync::register(&mut service, client); loop { let mut cmd = String::new(); diff --git a/src/block.rs b/src/block.rs index dce3803f5..1aea6cc53 100644 --- a/src/block.rs +++ b/src/block.rs @@ -21,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(), @@ -32,7 +41,15 @@ impl Block { } } - pub fn state_mut(&mut self) -> &mut State { &mut self.state } + /// Get a structure containing individual references to all public fields. + 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`. @@ -61,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, } @@ -84,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, @@ -95,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 @@ -103,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() { @@ -131,9 +153,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)), @@ -157,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()); @@ -173,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, @@ -205,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 { @@ -217,13 +239,26 @@ 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 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()); + 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()))) +} + #[test] fn open_block() { use spec::*; @@ -231,7 +266,30 @@ 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![]); } + +#[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 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()); +} diff --git a/src/blockchain.rs b/src/blockchain.rs index 3a1d24725..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::*; @@ -34,7 +33,7 @@ pub struct CacheSize { /// Information about best block gathered together struct BestBlock { pub hash: H256, - pub number: U256, + pub number: BlockNumber, pub total_difficulty: U256 } @@ -42,7 +41,7 @@ impl BestBlock { fn new() -> BestBlock { BestBlock { hash: H256::new(), - number: U256::from(0), + number: 0, total_difficulty: U256::from(0) } } @@ -59,7 +58,7 @@ pub struct BlockChain { // extra caches block_details: RwLock>, - block_hashes: RwLock>, + block_hashes: RwLock>, transaction_addresses: RwLock>, block_logs: RwLock>, blocks_blooms: RwLock>, @@ -93,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 { @@ -200,11 +199,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 @@ -337,9 +341,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 as BlockNumber), hash); } }, // route.blocks.len() could be 0 only if inserted block is best block, @@ -372,7 +376,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. @@ -410,8 +414,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: BlockNumber) -> Option { + self.query_extras(&index, &self.block_hashes) } /// Get best block hash. @@ -420,7 +424,7 @@ impl BlockChain { } /// Get best block number. - pub fn best_block_number(&self) -> U256 { + pub fn best_block_number(&self) -> BlockNumber { self.best_block.read().unwrap().number } @@ -430,7 +434,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()) } @@ -522,7 +526,6 @@ mod tests { use std::str::FromStr; use rustc_serialize::hex::FromHex; use util::hash::*; - use util::uint::*; use blockchain::*; #[test] @@ -537,25 +540,24 @@ 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(); bc.insert_block(&first); 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] @@ -585,64 +587,64 @@ 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()); + 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/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 e9d0b1485..b914dba19 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,22 +1,17 @@ -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::*; +use header::BlockNumber; +use spec::Spec; +use engine::Engine; /// General block status pub enum BlockStatus { /// Part of the blockchain. InChain, /// Queued for import. - Queued(QueueStatus), + Queued, /// Known as bad. Bad, /// Unknown. @@ -24,16 +19,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 { @@ -56,8 +42,6 @@ pub struct BlockQueueStatus { pub type TreeRoute = ::blockchain::TreeRoute; -pub type BlockNumber = u64; - /// Blockchain database client. Owns and manages a blockchain and a block queue. pub trait BlockChainClient : Sync { /// Get raw block header data by block header hash. @@ -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; @@ -112,14 +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>, } impl Client { - pub fn new(genesis: &[u8], path: &Path) -> Client { - let chain = Arc::new(BlockChain::new(genesis, 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, + }) } } @@ -147,25 +134,25 @@ impl BlockChainClient for Client { } fn block_header_at(&self, n: BlockNumber) -> Option { - self.chain.block_hash(&From::from(n)).and_then(|h| self.block_header(&h)) + self.chain.block_hash(n).and_then(|h| self.block_header(&h)) } fn block_body_at(&self, n: BlockNumber) -> Option { - self.chain.block_hash(&From::from(n)).and_then(|h| self.block_body(&h)) + self.chain.block_hash(n).and_then(|h| self.block_body(&h)) } fn block_at(&self, n: BlockNumber) -> Option { - self.chain.block_hash(&From::from(n)).and_then(|h| self.block(&h)) + self.chain.block_hash(n).and_then(|h| self.block(&h)) } fn block_status_at(&self, n: BlockNumber) -> BlockStatus { - match self.chain.block_hash(&From::from(n)) { + match self.chain.block_hash(n) { Some(h) => self.block_status(&h), None => BlockStatus::Unknown } } - 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 +171,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/engine.rs b/src/engine.rs index d16f25910..65f3a4b9f 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/env_info.rs b/src/env_info.rs index 919db314d..47b247f3c 100644 --- a/src/env_info.rs +++ b/src/env_info.rs @@ -1,4 +1,5 @@ use util::*; +use header::BlockNumber; /// Simple vector of hashes, should be at most 256 items large, can be smaller if being used /// for a block whose number is less than 257. @@ -7,11 +8,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: BlockNumber, /// The block author. pub author: Address, /// The block timestamp. - pub timestamp: U256, + pub timestamp: u64, /// The block difficulty. pub difficulty: U256, /// The block gas limit. @@ -20,4 +21,4 @@ pub struct EnvInfo { pub last_hashes: LastHashes, /// The gas used. pub gas_used: U256, -} \ No newline at end of file +} diff --git a/src/error.rs b/src/error.rs index 174d3c18c..99a64ce7a 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,6 +1,7 @@ //! General error types for use in ethcore. use util::*; +use header::BlockNumber; #[derive(Debug)] pub struct Mismatch { @@ -23,8 +24,8 @@ pub enum BlockError { InvalidSealArity(Mismatch), TooMuchGasUsed(OutOfBounds), InvalidUnclesHash(Mismatch), - UncleTooOld(OutOfBounds), - UncleIsBrother(OutOfBounds), + UncleTooOld(OutOfBounds), + UncleIsBrother(OutOfBounds), UncleInChain(H256), UncleParentNotInChain(H256), InvalidStateRoot, @@ -33,15 +34,22 @@ pub enum BlockError { InvalidDifficulty(Mismatch), InvalidGasLimit(OutOfBounds), InvalidReceiptsStateRoot, - InvalidTimestamp(OutOfBounds), + InvalidTimestamp(OutOfBounds), InvalidLogBloom, InvalidBlockNonce, InvalidParentHash(Mismatch), - InvalidNumber(OutOfBounds), + InvalidNumber(OutOfBounds), UnknownParent(H256), UnknownUncleParent(H256), } +#[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/ethereum/ethash.rs b/src/ethereum/ethash.rs index 337ce9c2b..c30a855a0 100644 --- a/src/ethereum/ethash.rs +++ b/src/ethereum/ethash.rs @@ -17,13 +17,31 @@ 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() } /// 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 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(); + + // 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))); + } } @@ -37,7 +55,7 @@ impl Engine for Ethash { return Err(From::from(BlockError::InvalidGasLimit(OutOfBounds { min: min_gas_limit, max: From::from(0), found: header.gas_limit }))); } let maximum_extra_data_size = self.maximum_extra_data_size(); - if header.number != From::from(0) && header.extra_data.len() > maximum_extra_data_size { + if header.number != 0 && header.extra_data.len() > maximum_extra_data_size { return Err(From::from(BlockError::ExtraDataOutOfBounds(OutOfBounds { min: 0, max: maximum_extra_data_size, found: header.extra_data.len() }))); } // TODO: Verify seal (quick) @@ -70,13 +88,13 @@ impl Engine for Ethash { impl Ethash { fn calculate_difficuty(&self, header: &Header, parent: &Header) -> U256 { const EXP_DIFF_PERIOD: u64 = 100000; - if header.number == From::from(0) { + if header.number == 0 { panic!("Can't calculate genesis block difficulty"); } let min_difficulty = decode(self.spec().engine_params.get("minimumDifficulty").unwrap()); let difficulty_bound_divisor = decode(self.spec().engine_params.get("difficultyBoundDivisor").unwrap()); - let duration_limit = decode(self.spec().engine_params.get("durationLimit").unwrap()); + let duration_limit: u64 = decode(self.spec().engine_params.get("durationLimit").unwrap()); let frontier_limit = decode(self.spec().engine_params.get("frontierCompatibilityModeLimit").unwrap()); let mut target = if header.number < frontier_limit { if header.timestamp >= parent.timestamp + duration_limit { @@ -87,16 +105,16 @@ impl Ethash { } } else { - let diff_inc = (header.timestamp - parent.timestamp) / From::from(10); - if diff_inc <= From::from(1) { - parent.difficulty + parent.difficulty / From::from(2048) * (U256::from(1) - diff_inc) + let diff_inc = (header.timestamp - parent.timestamp) / 10; + if diff_inc <= 1 { + parent.difficulty + parent.difficulty / From::from(2048) * From::from(1 - diff_inc) } else { - parent.difficulty - parent.difficulty / From::from(2048) * max(diff_inc - From::from(1), From::from(99)) + parent.difficulty - parent.difficulty / From::from(2048) * From::from(max(diff_inc - 1, 99)) } }; target = max(min_difficulty, target); - let period = ((parent.number + From::from(1)).as_u64() / EXP_DIFF_PERIOD) as usize; + let period = ((parent.number + 1) / EXP_DIFF_PERIOD) as usize; if period > 1 { target = max(min_difficulty, target + (U256::from(1) << (period - 2))); } @@ -111,9 +129,10 @@ 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()); + assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244f40000").unwrap()); } // TODO: difficulty test 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/extras.rs b/src/extras.rs index 39ce814c8..ed0032698 100644 --- a/src/extras.rs +++ b/src/extras.rs @@ -1,4 +1,5 @@ use util::*; +use header::BlockNumber; use rocksdb::{DB, Writable}; /// Represents index of extra data in database @@ -74,6 +75,13 @@ impl ExtrasSliceConvertable for U256 { } } +// NICE: make less horrible. +impl ExtrasSliceConvertable for BlockNumber { + 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 +96,7 @@ impl ExtrasIndexable for H256 { /// Familial details concerning a block #[derive(Debug, Clone)] pub struct BlockDetails { - pub number: U256, + pub number: BlockNumber, pub total_difficulty: U256, pub parent: H256, pub children: Vec diff --git a/src/header.rs b/src/header.rs index 80c38c05f..5a274bb5e 100644 --- a/src/header.rs +++ b/src/header.rs @@ -1,5 +1,8 @@ use util::*; use basic_types::*; +use time::now_utc; + +pub type BlockNumber = u64; /// A block header. /// @@ -11,8 +14,8 @@ use basic_types::*; pub struct Header { // TODO: make all private. pub parent_hash: H256, - pub timestamp: U256, - pub number: U256, + pub timestamp: u64, + pub number: BlockNumber, pub author: Address, pub transactions_root: H256, @@ -41,8 +44,8 @@ impl Header { pub fn new() -> Header { Header { parent_hash: ZERO_H256.clone(), - timestamp: BAD_U256, - number: ZERO_U256, + timestamp: 0, + number: 0, author: ZERO_ADDRESS.clone(), transactions_root: SHA3_NULL_RLP, @@ -61,14 +64,23 @@ impl Header { } } + pub fn number(&self) -> BlockNumber { 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: BlockNumber) { 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 82083a1cc..f090ba83a 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/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/spec.rs b/src/spec.rs index d3f516eb3..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)] @@ -60,14 +81,14 @@ pub struct Spec { pub difficulty: U256, pub gas_limit: U256, pub gas_used: U256, - pub timestamp: 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,18 +103,18 @@ 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 { 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(), @@ -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)) }); } } } @@ -181,12 +202,12 @@ 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: 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, 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/chain.rs b/src/sync/chain.rs index bfbf3cfb8..ffa5d8add 100644 --- a/src/sync/chain.rs +++ b/src/sync/chain.rs @@ -16,9 +16,10 @@ use util::*; use std::mem::{replace}; use views::{HeaderView}; -use header::{Header as BlockHeader}; -use client::{BlockNumber, BlockChainClient, BlockStatus, QueueStatus, ImportResult}; +use header::{BlockNumber, Header as BlockHeader}; +use client::{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/mod.rs b/src/sync/mod.rs index a070b2d59..300465014 100644 --- a/src/sync/mod.rs +++ b/src/sync/mod.rs @@ -16,9 +16,8 @@ /// /// fn main() { /// let mut service = NetworkService::start().unwrap(); -/// let frontier = ethereum::new_frontier(); /// let dir = env::temp_dir(); -/// let client = Arc::new(Client::new(&frontier.genesis_block(), &dir)); +/// let client = Arc::new(Client::new(ethereum::new_frontier(), &dir).unwrap()); /// EthSync::register(&mut service, client); /// } /// ``` diff --git a/src/sync/tests.rs b/src/sync/tests.rs index dfcf75c8b..6a045fa1e 100644 --- a/src/sync/tests.rs +++ b/src/sync/tests.rs @@ -6,8 +6,8 @@ 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 header::Header as BlockHeader; +use client::{BlockChainClient, BlockStatus, TreeRoute, BlockQueueStatus, BlockChainInfo, ImportResult}; +use header::{Header as BlockHeader, BlockNumber}; use sync::io::SyncIo; use sync::chain::ChainSync; @@ -39,7 +39,7 @@ impl TestBlockChainClient { let mut header = BlockHeader::new(); header.difficulty = From::from(n); header.parent_hash = self.last_hash.clone(); - header.number = From::from(n); + header.number = n as BlockNumber; let mut uncles = RlpStream::new_list(if empty {0} else {1}); if !empty { uncles.append(&H256::from(&U256::from(n))); @@ -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 { @@ -118,7 +118,7 @@ impl BlockChainClient for TestBlockChainClient { fn import_block(&mut self, b: &[u8]) -> ImportResult { let header = Rlp::new(&b).val_at::(0); - let number: usize = header.number.low_u64() as usize; + let number: usize = header.number as usize; if number > self.blocks.len() { panic!("Unexpected block number. Expected {}, got {}", self.blocks.len(), number); } @@ -126,7 +126,7 @@ impl BlockChainClient for TestBlockChainClient { match self.blocks.get(&header.parent_hash) { Some(parent) => { let parent = Rlp::new(parent).val_at::(0); - if parent.number != (header.number - From::from(1)) { + if parent.number != (header.number - 1) { panic!("Unexpected block parent"); } }, @@ -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 { diff --git a/src/verification.rs b/src/verification.rs index 2b843134b..e27536187 100644 --- a/src/verification.rs +++ b/src/verification.rs @@ -6,7 +6,6 @@ /// 3. Final verification against the blockchain done before enactment. use common::*; -use client::BlockNumber; use engine::Engine; use blockchain::BlockChain; @@ -82,12 +81,12 @@ pub fn verify_block_final(bytes: &[u8], engine: &mut Engine, bc: &BlockChain) -> // 6 7 // (8 Invalid) - let depth = if header.number > uncle.number { header.number - uncle.number } else { From::from(0) }; - if depth > From::from(6) { - return Err(From::from(BlockError::UncleTooOld(OutOfBounds { min: header.number - depth, max: header.number - From::from(1), found: uncle.number }))); + let depth = if header.number > uncle.number { header.number - uncle.number } else { 0 }; + if depth > 6 { + return Err(From::from(BlockError::UncleTooOld(OutOfBounds { min: header.number - depth, max: header.number - 1, found: uncle.number }))); } - else if depth < From::from(1) { - return Err(From::from(BlockError::UncleIsBrother(OutOfBounds { min: header.number - depth, max: header.number - From::from(1), found: uncle.number }))); + else if depth < 1 { + return Err(From::from(BlockError::UncleIsBrother(OutOfBounds { min: header.number - depth, max: header.number - 1, found: uncle.number }))); } // cB @@ -100,7 +99,7 @@ pub fn verify_block_final(bytes: &[u8], engine: &mut Engine, bc: &BlockChain) -> // cB.p^7 -------------/ // cB.p^8 let mut expected_uncle_parent = header.parent_hash.clone(); - for _ in 0..depth.as_u32() { + for _ in 0..depth { expected_uncle_parent = bc.block_details(&expected_uncle_parent).unwrap().parent; } if expected_uncle_parent != uncle_parent.hash() { @@ -116,7 +115,7 @@ pub fn verify_block_final(bytes: &[u8], engine: &mut Engine, bc: &BlockChain) -> /// Check basic header parameters. fn verify_header(header: &Header) -> Result<(), Error> { if header.number > From::from(BlockNumber::max_value()) { - return Err(From::from(BlockError::InvalidNumber(OutOfBounds { max: From::from(BlockNumber::max_value()), min: From::from(0), found: header.number }))) + return Err(From::from(BlockError::InvalidNumber(OutOfBounds { max: From::from(BlockNumber::max_value()), min: 0, found: header.number }))) } if header.gas_used > header.gas_limit { return Err(From::from(BlockError::TooMuchGasUsed(OutOfBounds { max: header.gas_limit, min: From::from(0), found: header.gas_used }))); @@ -130,10 +129,10 @@ fn verify_parent(header: &Header, parent: &Header) -> Result<(), Error> { return Err(From::from(BlockError::InvalidParentHash(Mismatch { expected: parent.hash(), found: header.parent_hash.clone() }))) } if header.timestamp <= parent.timestamp { - return Err(From::from(BlockError::InvalidTimestamp(OutOfBounds { max: BAD_U256, min: parent.timestamp + From::from(1), found: header.timestamp }))) + return Err(From::from(BlockError::InvalidTimestamp(OutOfBounds { max: u64::max_value(), min: parent.timestamp + 1, found: header.timestamp }))) } if header.number <= parent.number { - return Err(From::from(BlockError::InvalidNumber(OutOfBounds { max: From::from(BlockNumber::max_value()), min: parent.number + From::from(1), found: header.number }))); + return Err(From::from(BlockError::InvalidNumber(OutOfBounds { max: BlockNumber::max_value(), min: parent.number + 1, found: header.number }))); } Ok(()) } diff --git a/src/views.rs b/src/views.rs index 0f8225393..7a1a20e9f 100644 --- a/src/views.rs +++ b/src/views.rs @@ -113,8 +113,8 @@ 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) -> BlockNumber { 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) -> u64 { self.rlp.val_at(11) } /// Returns block extra data. pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) }