cleanup

src/block.rs

@@ -1,86 +1,6 @@
 use util::hash::*;
 use util::overlaydb::*;
-use util::rlp::*;
-use util::sha3::*;
-use blockheader::*;
 use state::*;
-use transaction::*;
-use extras::*;
-
-/// view onto block rlp
-pub struct BlockView<'a> {
-	rlp: Rlp<'a>
-}
-
-impl<'a> BlockView<'a> {
-	/// Creates new view onto block from raw bytes
-	pub fn new(bytes: &'a [u8]) -> BlockView<'a> {
-		BlockView {
-			rlp: Rlp::new(bytes)
-		}
-	}
-
-	/// Creates new view onto block from rlp
-	pub fn new_from_rlp(rlp: Rlp<'a>) -> BlockView<'a> {
-		BlockView {
-			rlp: rlp
-		}
-	}
-
-	/// Return reference to underlaying rlp
-	pub fn rlp(&self) -> &Rlp<'a> { 
-		&self.rlp 
-	}
-
-	/// Create new Header object from header rlp
-	pub fn header(&self) -> Header { 
-		self.rlp.val_at(0)
-	}
-
-	/// Create new header view obto block head rlp
-	pub fn header_view(&self) -> HeaderView<'a> { 
-		HeaderView::new_from_rlp(self.rlp.at(0)) 
-	}
-
-	/// Return List of transactions in given block
-	pub fn transactions(&self) -> Vec<Transaction> {
-		self.rlp.val_at(1)
-	}
-
-	/// Return transaction hashes
-	pub fn transaction_hashes(&self) -> Vec<H256> { 
-		self.rlp.at(1).iter().map(|rlp| rlp.raw().sha3()).collect()
-	}
-
-	/// Return list of uncles of given block
-	pub fn uncles(&self) -> Vec<Header> {
-		self.rlp.val_at(2)
-	}
-
-	/// Return list of uncle hashes of given block
-	pub fn uncle_hashes(&self) -> Vec<H256> { 
-		self.rlp.at(2).iter().map(|rlp| rlp.raw().sha3()).collect()
-	}
-
-	/// Return BlockDetaile object of given block
-	/// note* children is always an empty vector,
-	/// cause we can't deducate them from rlp.
-	pub fn block_details(&self) -> BlockDetails {
-		let header = self.header_view();
-		BlockDetails {
-			number: header.number(),
-			total_difficulty: header.difficulty(),
-			parent: header.parent_hash(),
-			children: vec![]
-		}
-	}
-}
-
-impl<'a> Hashable for BlockView<'a> {
-	fn sha3(&self) -> H256 {
-		self.header_view().sha3()
-	}
-}
 
 /// Active model of a block within the blockchain
 pub struct Block {

src/blockchain.rs

@@ -12,10 +12,10 @@ use util::sha3::*;
 use util::bytes::*;
 use util::squeeze::*;
 use blockheader::*;
-use block::*;
 use genesis::*;
 use extras::*;
 use transaction::*;
+use views::*;
 
 #[derive(Debug)]
 pub struct CacheSize {

src/blockheader.rs

@@ -2,54 +2,6 @@ use util::hash::*;
 use util::bytes::*;
 use util::uint::*;
 use util::rlp::*;
-use util::sha3;
-
-/// view onto block header rlp
-pub struct HeaderView<'a> {
-	rlp: Rlp<'a>
-}
-
-impl<'a> HeaderView<'a> {
-	pub fn new(bytes: &'a [u8]) -> HeaderView<'a> {
-		HeaderView {
-			rlp: Rlp::new(bytes)
-		}
-	}
-
-	pub fn new_from_rlp(rlp: Rlp<'a>) -> HeaderView<'a> {
-		HeaderView {
-			rlp: rlp
-		}
-	}
-
-	pub fn rlp(&self) -> &Rlp<'a> { &self.rlp }
-	pub fn parent_hash(&self) -> H256 { self.rlp.val_at(0) }
-	pub fn uncles_hash(&self) -> H256 { self.rlp.val_at(1) }
-	pub fn author(&self) -> Address { self.rlp.val_at(2) }
-	pub fn state_root(&self) -> H256 { self.rlp.val_at(3) }
-	pub fn transactions_root(&self) -> H256 { self.rlp.val_at(4) }
-	pub fn receipts_root(&self) -> H256 { self.rlp.val_at(5) }
-	pub fn log_bloom(&self) -> H2048 { self.rlp.val_at(6) }
-	pub fn difficulty(&self) -> U256 { self.rlp.val_at(7) }
-	pub fn number(&self) -> U256 { self.rlp.val_at(8) }
-	pub fn gas_limit(&self) -> U256 { self.rlp.val_at(9) }
-	pub fn gas_used(&self) -> U256 { self.rlp.val_at(10) }
-	pub fn timestamp(&self) -> U256 { self.rlp.val_at(11) }
-	pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) }
-	pub fn seal(&self) -> Vec<Bytes> { 
-		let mut seal = vec![];
-		for i in 13..self.rlp.item_count() {
-			seal.push(self.rlp.val_at(i));
-		}
-		seal
-	}
-}
-
-impl<'a> sha3::Hashable for HeaderView<'a> {
-	fn sha3(&self) -> H256 {
-		self.rlp.raw().sha3()
-	}
-}
 
 pub static ZERO_ADDRESS: Address = Address([0x00; 20]);
 pub static ZERO_H256: H256 = H256([0x00; 32]);

src/genesis.rs

@@ -103,7 +103,7 @@ impl Genesis {
 
 #[test]
 fn test_genesis() {
-	use block::*;
+	use views::*;
 
 	let g = Genesis::new_frontier();
 	let view = BlockView::new(&g.block).header_view();

src/importroute.rs

@@ -1,8 +0,0 @@
-use util::hash::*;
-use transaction::*;
-
-pub struct ImportRoute {
-	_dead_blocks: Vec<H256>,
-	_live_blocks: Vec<H256>,
-	_transactions: Vec<Transaction>
-}

src/lib.rs

@@ -94,8 +94,7 @@ pub mod blockheader;
 pub mod transaction;
 pub mod extras;
 pub mod genesis;
-pub mod verifiedblock;
+pub mod views;
-pub mod importroute;
 
 pub mod networkparams;
 pub mod denominations;

src/verifiedblock.rs

@@ -1,17 +0,0 @@
-use blockheader::*;
-use transaction::*;
-
-pub struct VerifiedBlock<'a> {
-	_blockview: HeaderView<'a>,
-	_transactions: Vec<Transaction>
-}
-
-impl<'a> VerifiedBlock<'a> {
-	// todo, new should also take transactions
-	pub fn new(bytes: &'a [u8]) -> VerifiedBlock<'a> {
-		VerifiedBlock {
-			_blockview: HeaderView::new(bytes),
-			_transactions: vec![]
-		}
-	}
-}

src/views.rs

@@ -0,0 +1,162 @@
+//! Block oriented views onto rlp.
+use util::bytes::*;
+use util::hash::*;
+use util::uint::*;
+use util::rlp::*;
+use util::sha3::*;
+use blockheader::*;
+use transaction::*;
+use extras::*;
+
+/// View onto block rlp.
+pub struct BlockView<'a> {
+	rlp: Rlp<'a>
+}
+
+impl<'a> BlockView<'a> {
+	/// Creates new view onto block from raw bytes.
+	pub fn new(bytes: &'a [u8]) -> BlockView<'a> {
+		BlockView {
+			rlp: Rlp::new(bytes)
+		}
+	}
+
+	/// Creates new view onto block from rlp.
+	pub fn new_from_rlp(rlp: Rlp<'a>) -> BlockView<'a> {
+		BlockView {
+			rlp: rlp
+		}
+	}
+
+	/// Return reference to underlaying rlp.
+	pub fn rlp(&self) -> &Rlp<'a> { 
+		&self.rlp 
+	}
+
+	/// Create new Header object from header rlp.
+	pub fn header(&self) -> Header { 
+		self.rlp.val_at(0)
+	}
+
+	/// Create new header view obto block head rlp.
+	pub fn header_view(&self) -> HeaderView<'a> { 
+		HeaderView::new_from_rlp(self.rlp.at(0)) 
+	}
+
+	/// Return List of transactions in given block.
+	pub fn transactions(&self) -> Vec<Transaction> {
+		self.rlp.val_at(1)
+	}
+
+	/// Return transaction hashes.
+	pub fn transaction_hashes(&self) -> Vec<H256> { 
+		self.rlp.at(1).iter().map(|rlp| rlp.raw().sha3()).collect()
+	}
+
+	/// Return list of uncles of given block.
+	pub fn uncles(&self) -> Vec<Header> {
+		self.rlp.val_at(2)
+	}
+
+	/// Return list of uncle hashes of given block.
+	pub fn uncle_hashes(&self) -> Vec<H256> { 
+		self.rlp.at(2).iter().map(|rlp| rlp.raw().sha3()).collect()
+	}
+
+	/// Return BlockDetaile object of given block
+	/// note* children is always an empty vector,
+	/// cause we can't deducate them from rlp.
+	pub fn block_details(&self) -> BlockDetails {
+		let header = self.header_view();
+		BlockDetails {
+			number: header.number(),
+			total_difficulty: header.difficulty(),
+			parent: header.parent_hash(),
+			children: vec![]
+		}
+	}
+}
+
+impl<'a> Hashable for BlockView<'a> {
+	fn sha3(&self) -> H256 {
+		self.header_view().sha3()
+	}
+}
+
+/// View onto block header rlp.
+pub struct HeaderView<'a> {
+	rlp: Rlp<'a>
+}
+
+impl<'a> HeaderView<'a> {
+	/// Creates new view onto header from raw bytes.
+	pub fn new(bytes: &'a [u8]) -> HeaderView<'a> {
+		HeaderView {
+			rlp: Rlp::new(bytes)
+		}
+	}
+
+	/// Creates new view onto header from rlp.
+	pub fn new_from_rlp(rlp: Rlp<'a>) -> HeaderView<'a> {
+		HeaderView {
+			rlp: rlp
+		}
+	}
+
+	/// Returns raw rlp.
+	pub fn rlp(&self) -> &Rlp<'a> { &self.rlp }
+
+	/// Returns parent hash.
+	pub fn parent_hash(&self) -> H256 { self.rlp.val_at(0) }
+
+	/// Returns uncles hash.
+	pub fn uncles_hash(&self) -> H256 { self.rlp.val_at(1) }
+
+	/// Returns author.
+	pub fn author(&self) -> Address { self.rlp.val_at(2) }
+
+	/// Returns state root.
+	pub fn state_root(&self) -> H256 { self.rlp.val_at(3) }
+
+	/// Returns transactions root.
+	pub fn transactions_root(&self) -> H256 { self.rlp.val_at(4) }
+
+	/// Returns block receipts root.
+	pub fn receipts_root(&self) -> H256 { self.rlp.val_at(5) }
+	
+	/// Returns block log bloom.
+	pub fn log_bloom(&self) -> H2048 { self.rlp.val_at(6) }
+
+	/// Returns block difficulty.
+	pub fn difficulty(&self) -> U256 { self.rlp.val_at(7) }
+
+	/// Returns block number.
+	pub fn number(&self) -> U256 { self.rlp.val_at(8) }
+	
+	/// Returns block gas limit.
+	pub fn gas_limit(&self) -> U256 { self.rlp.val_at(9) }
+
+	/// Returns block gas used.
+	pub fn gas_used(&self) -> U256 { self.rlp.val_at(10) }
+
+	/// Returns timestamp.
+	pub fn timestamp(&self) -> U256 { self.rlp.val_at(11) }
+
+	/// Returns block extra data.
+	pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) }
+
+	/// Returns block seal.
+	pub fn seal(&self) -> Vec<Bytes> { 
+		let mut seal = vec![];
+		for i in 13..self.rlp.item_count() {
+			seal.push(self.rlp.val_at(i));
+		}
+		seal
+	}
+}
+
+impl<'a> Hashable for HeaderView<'a> {
+	fn sha3(&self) -> H256 {
+		self.rlp.raw().sha3()
+	}
+}