directory reorg

src/chain/block.rs

@@ -1,10 +1,11 @@
-use block_header::BlockHeader;
+use chain::{BlockHeader, Transaction};
+use chain::merkle_root::merkle_root;
 use crypto::dhash256;
 use hash::H256;
-use merkle_root::merkle_root;
-use reader::{Deserializable, Reader, Error as ReaderError};
-use stream::{Serializable, Stream, serialize};
-use transaction::Transaction;
+use ser::{
+	Deserializable, Reader, Error as ReaderError,
+	Serializable, Stream, serialize
+};
 
 pub struct Block {
 	block_header: BlockHeader,
@@ -48,7 +49,7 @@ impl Block {
 #[cfg(test)]
 mod tests {
 	use hex::FromHex;
-	use reader::deserialize;
+	use ser::deserialize;
 	use hash::h256_from_str;
 	use super::Block;
 

src/chain/block_header.rs

@@ -1,6 +1,8 @@
 use std::fmt;
-use reader::{Deserializable, Reader, Error as ReaderError};
-use stream::{Serializable, Stream};
+use ser::{
+	Deserializable, Reader, Error as ReaderError,
+	Serializable, Stream
+};
 use hash::{H256, h256_to_str};
 
 #[derive(Debug, PartialEq)]
@@ -62,8 +64,7 @@ impl Deserializable for BlockHeader {
 
 #[cfg(test)]
 mod tests {
-	use reader::{Reader, Error as ReaderError};
-	use stream::Stream;
+	use ser::{Reader, Error as ReaderError, Stream};
 	use super::BlockHeader;
 
 	#[test]

src/chain/mod.rs

@@ -0,0 +1,12 @@
+mod block;
+mod block_header;
+mod merkle_root;
+mod transaction;
+
+pub use self::block::Block;
+pub use self::block_header::BlockHeader;
+pub use self::transaction::{
+	Transaction, TransactionInput, TransactionOutput, OutPoint,
+	SEQUENCE_LOCKTIME_DISABLE_FLAG, SEQUENCE_FINAL,
+	SEQUENCE_LOCKTIME_TYPE_FLAG, SEQUENCE_LOCKTIME_MASK
+};

src/chain/transaction.rs

@@ -3,11 +3,13 @@
 //! https://en.bitcoin.it/wiki/Protocol_documentation#tx
 
 use hex::FromHex;
-use bytes::Bytes;
-use reader::{Deserializable, Reader, Error as ReaderError, deserialize};
+use primitives::Bytes;
+use ser::{
+	Deserializable, Reader, Error as ReaderError, deserialize,
+	Serializable, Stream, serialize
+};
 use crypto::dhash256;
 use hash::H256;
-use stream::{Serializable, Stream, serialize};
 
 // Below flags apply in the context of BIP 68
 // If this flag set, CTxIn::nSequence is NOT interpreted as a
@@ -218,7 +220,7 @@ impl Transaction {
 #[cfg(test)]
 mod tests {
 	use hex::FromHex;
-	use reader::deserialize;
+	use ser::deserialize;
 	use hash::h256_from_str;
 	use super::Transaction;
 

src/lib.rs

@@ -1,4 +1,14 @@
 //! Ethcore's bitcoin library.
+//!
+//! module(depends_on..)
+//!
+//! net(primitives, serialization)
+//! script(primitives, serialization, chain)
+//! chain(primitives, serialization)
+//! keys(primitives, crypto)
+//! crypto(primitives)
+//! serialization(primitives)
+//! primitives
 
 extern crate rand;
 extern crate byteorder;
@@ -9,20 +19,15 @@ extern crate lazy_static;
 extern crate secp256k1;
 extern crate base58;
 
+pub mod chain;
 pub mod keys;
 pub mod net;
+pub mod primitives;
 pub mod script;
+pub mod ser;
 
-pub mod block;
-pub mod block_header;
-pub mod bytes;
-pub mod compact_integer;
 pub mod crypto;
 pub mod hash;
-pub mod merkle_root;
 pub mod network;
-pub mod reader;
-pub mod stream;
-pub mod transaction;
 
 pub use rustc_serialize::hex;

src/net/address.rs

@@ -1,7 +1,9 @@
 use std::{net, str};
 use byteorder::{BigEndian, WriteBytesExt, ReadBytesExt};
-use stream::{Stream, Serializable};
-use reader::{Reader, Deserializable, Error as ReaderError};
+use ser::{
+	Stream, Serializable,
+	Reader, Deserializable, Error as ReaderError
+};
 use net::ServiceFlags;
 
 #[derive(Debug, PartialEq)]
@@ -117,8 +119,7 @@ impl Deserializable for NetAddress {
 
 #[cfg(test)]
 mod tests {
-	use stream::serialize;
-	use reader::deserialize;
+	use ser::{serialize, deserialize};
 	use net::ServiceFlags;
 	use super::NetAddress;
 

src/net/service.rs

@@ -1,5 +1,7 @@
-use stream::{Serializable, Stream};
-use reader::{Deserializable, Reader, Error as ReaderError};
+use ser::{
+	Serializable, Stream,
+	Deserializable, Reader, Error as ReaderError
+};
 
 #[derive(Debug, Default, PartialEq, Clone, Copy)]
 pub struct ServiceFlags(u64);

src/primitives/bytes.rs

@@ -1,8 +1,5 @@
 use std::{ops, str, fmt};
 use hex::{ToHex, FromHex, FromHexError};
-use compact_integer::CompactInteger;
-use stream::{Stream, Serializable};
-use reader::{Reader, Deserializable, Error as ReaderError};
 
 #[derive(Default, PartialEq, Clone)]
 pub struct Bytes(Vec<u8>);
@@ -53,25 +50,8 @@ impl ops::DerefMut for Bytes {
 	}
 }
 
-impl Serializable for Bytes {
-	fn serialize(&self, stream: &mut Stream) {
-		stream
-			.append(&CompactInteger::from(self.0.len()))
-			.append_slice(&self.0);
-	}
-}
-
-impl Deserializable for Bytes {
-	fn deserialize(reader: &mut Reader) -> Result<Self, ReaderError> where Self: Sized {
-		let len = try!(reader.read::<CompactInteger>());
-		reader.read_slice(len.into()).map(|b| Bytes(b.to_vec()))
-	}
-}
-
 #[cfg(test)]
 mod tests {
-	use stream::serialize;
-	use reader::deserialize;
 	use super::Bytes;
 
 	#[test]
@@ -80,20 +60,6 @@ mod tests {
 		assert_eq!(bytes, vec![0x01, 0x45].into());
 	}
 
-	#[test]
-	fn test_bytes_serialize() {
-		let expected = vec![0x02, 0x01, 0x45];
-		let bytes: Bytes = "0145".into();
-		assert_eq!(expected, serialize(&bytes));
-	}
-
-	#[test]
-	fn test_bytes_deserialize() {
-		let raw = vec![0x02, 0x01, 0x45];
-		let expected: Bytes = "0145".into();
-		assert_eq!(expected, deserialize(&raw).unwrap());
-	}
-
 	#[test]
 	fn test_bytes_debug_formatter() {
 		let bytes: Bytes = "0145".into();

src/primitives/mod.rs

@@ -0,0 +1,3 @@
+mod bytes;
+
+pub use self::bytes::Bytes;

src/script/builder.rs

@@ -1,4 +1,4 @@
-use bytes::Bytes;
+use primitives::Bytes;
 use script::{Opcode, Script, Num};
 
 #[derive(Default)]

src/script/interpreter.rs

@@ -1,7 +1,7 @@
 use std::{cmp, mem};
-use bytes::Bytes;
+use primitives::Bytes;
 use keys::{Signature, Public};
-use transaction::SEQUENCE_LOCKTIME_DISABLE_FLAG;
+use chain::SEQUENCE_LOCKTIME_DISABLE_FLAG;
 use crypto::{sha1, sha256, dhash160, dhash256, ripemd160};
 use script::{
 	script, Script, Num, VerificationFlags, Opcode, Error,
@@ -891,8 +891,8 @@ pub fn eval_script(
 #[cfg(test)]
 mod tests {
 	use hex::FromHex;
-	use bytes::Bytes;
-	use transaction::Transaction;
+	use primitives::Bytes;
+	use chain::Transaction;
 	use script::{
 		Opcode, Script, VerificationFlags, Builder, Error, Num, TransactionInputSigner,
 		NoopSignatureChecker, SignatureVersion, TransactionSignatureChecker, Stack

src/script/num.rs

@@ -1,6 +1,6 @@
 //! Script numeric.
 use std::ops;
-use bytes::Bytes;
+use primitives::Bytes;
 use script::Error;
 
 /// Numeric opcodes (OP_1ADD, etc) are restricted to operating on 4-byte integers.

src/script/script.rs

@@ -1,8 +1,8 @@
 //! Serialized script, used inside transaction inputs and outputs.
 
 use std::{fmt, ops};
-use bytes::Bytes;
 use hex::ToHex;
+use primitives::Bytes;
 use script::{Opcode, Error};
 
 /// Maximum number of bytes pushable to the stack

src/script/sign.rs

@@ -1,10 +1,10 @@
 use script::{Script, Builder};
-use bytes::Bytes;
+use primitives::Bytes;
 use keys::KeyPair;
 use crypto::dhash256;
 use hash::{H256, h256_from_u8};
-use stream::Stream;
-use transaction::{Transaction, TransactionOutput, OutPoint, TransactionInput};
+use ser::Stream;
+use chain::{Transaction, TransactionOutput, OutPoint, TransactionInput};
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum SignatureVersion {
@@ -224,10 +224,10 @@ impl TransactionInputSigner {
 #[cfg(test)]
 mod tests {
 	use hex::FromHex;
-	use bytes::Bytes;
+	use primitives::Bytes;
 	use hash::h256_from_str;
 	use keys::{KeyPair, Private, Address};
-	use transaction::{OutPoint, TransactionOutput, Transaction};
+	use chain::{OutPoint, TransactionOutput, Transaction};
 	use script::Script;
 	use super::{UnsignedTransactionInput, TransactionInputSigner, SighashBase};
 

src/script/verify.rs

@@ -1,6 +1,6 @@
 use keys::{Public, Signature};
 use script::{script, SignatureVersion, Script, TransactionInputSigner, Num};
-use transaction::{
+use chain::{
 	SEQUENCE_FINAL, SEQUENCE_LOCKTIME_DISABLE_FLAG,
 	SEQUENCE_LOCKTIME_MASK, SEQUENCE_LOCKTIME_TYPE_FLAG
 };

src/ser/compact_integer.rs

@@ -2,8 +2,10 @@
 //! https://bitcoin.org/en/developer-reference#compactsize-unsigned-integers
 
 use std::fmt;
-use stream::{Serializable, Stream};
-use reader::{Deserializable, Reader, Error as ReaderError};
+use ser::{
+	Serializable, Stream,
+	Deserializable, Reader, Error as ReaderError
+};
 
 /// A type of variable-length integer commonly used in the Bitcoin P2P protocol and Bitcoin serialized data structures.
 #[derive(Default, Debug, Clone, Copy, PartialEq)]
@@ -97,8 +99,7 @@ impl Deserializable for CompactInteger {
 
 #[cfg(test)]
 mod tests {
-	use reader::{Reader, Error as ReaderError};
-	use stream::Stream;
+	use ser::{Reader, Error as ReaderError, Stream};
 	use super::CompactInteger;
 
 	#[test]

src/ser/mod.rs

@@ -0,0 +1,6 @@
+mod compact_integer;
+pub mod reader;
+pub mod stream;
+
+pub use self::reader::{Reader, Deserializable, deserialize, Error};
+pub use self::stream::{Stream, Serializable, serialize};

src/ser/reader.rs

@@ -1,6 +1,7 @@
 use std::{io, cmp};
 use byteorder::{LittleEndian, ReadBytesExt};
-use compact_integer::CompactInteger;
+use primitives::Bytes;
+use ser::compact_integer::CompactInteger;
 
 pub fn deserialize<T>(buffer: &[u8]) -> Result<T, Error> where T: Deserializable {
 	let mut reader = Reader::new(buffer);
@@ -118,9 +119,17 @@ impl Deserializable for u64 {
 	}
 }
 
+impl Deserializable for Bytes {
+	fn deserialize(reader: &mut Reader) -> Result<Self, Error> where Self: Sized {
+		let len = try!(reader.read::<CompactInteger>());
+		reader.read_slice(len.into()).map(|b| b.to_vec().into())
+	}
+}
+
 #[cfg(test)]
 mod test {
-	use super::{Reader, Error};
+	use primitives::Bytes;
+	use super::{Reader, Error, deserialize};
 
 	#[test]
 	fn test_reader_read() {
@@ -140,4 +149,11 @@ mod test {
 		assert!(reader.is_finished());
 		assert_eq!(Error::UnexpectedEnd, reader.read::<u8>().unwrap_err());
 	}
+
+	#[test]
+	fn test_bytes_deserialize() {
+		let raw = vec![0x02, 0x01, 0x45];
+		let expected: Bytes = "0145".into();
+		assert_eq!(expected, deserialize(&raw).unwrap());
+	}
 }

src/ser/stream.rs

@@ -1,7 +1,8 @@
 //! Stream used for serialization.
 use std::io::{self, Write};
 use byteorder::{LittleEndian, WriteBytesExt};
-use compact_integer::CompactInteger;
+use primitives::Bytes;
+use ser::compact_integer::CompactInteger;
 
 pub fn serialize(t: &Serializable) -> Vec<u8> {
 	let mut stream = Stream::default();
@@ -96,9 +97,18 @@ impl Serializable for u64 {
 	}
 }
 
+impl Serializable for Bytes {
+	fn serialize(&self, stream: &mut Stream) {
+		stream
+			.append(&CompactInteger::from(self.len()))
+			.append_slice(&self);
+	}
+}
+
 #[cfg(test)]
 mod tests {
-	use super::Stream;
+	use primitives::Bytes;
+	use super::{Stream, serialize};
 
 	#[test]
 	fn test_stream_append() {
@@ -119,4 +129,12 @@ mod tests {
 
 		assert_eq!(expected, stream.out());
 	}
+
+	#[test]
+	fn test_bytes_serialize() {
+		let expected = vec![0x02, 0x01, 0x45];
+		let bytes: Bytes = "0145".into();
+		assert_eq!(expected, serialize(&bytes));
+	}
+
 }