From 3736512935c7ed49f84a08b35589301bd49102a8 Mon Sep 17 00:00:00 2001 From: debris Date: Sun, 18 Sep 2016 18:12:45 +0200 Subject: [PATCH] directory reorg --- src/{ => chain}/block.rs | 13 ++++++------ src/{ => chain}/block_header.rs | 9 +++++---- src/{ => chain}/merkle_root.rs | 0 src/chain/mod.rs | 12 +++++++++++ src/{ => chain}/transaction.rs | 10 ++++++---- src/lib.rs | 21 ++++++++++++-------- src/net/address.rs | 9 +++++---- src/net/service.rs | 6 ++++-- src/{ => primitives}/bytes.rs | 34 -------------------------------- src/primitives/mod.rs | 3 +++ src/script/builder.rs | 2 +- src/script/interpreter.rs | 8 ++++---- src/script/num.rs | 2 +- src/script/script.rs | 2 +- src/script/sign.rs | 10 +++++----- src/script/verify.rs | 2 +- src/{ => ser}/compact_integer.rs | 9 +++++---- src/ser/mod.rs | 6 ++++++ src/{ => ser}/reader.rs | 20 +++++++++++++++++-- src/{ => ser}/stream.rs | 22 +++++++++++++++++++-- 20 files changed, 117 insertions(+), 83 deletions(-) rename src/{ => chain}/block.rs (91%) rename src/{ => chain}/block_header.rs (94%) rename src/{ => chain}/merkle_root.rs (100%) create mode 100644 src/chain/mod.rs rename src/{ => chain}/transaction.rs (97%) rename src/{ => primitives}/bytes.rs (56%) create mode 100644 src/primitives/mod.rs rename src/{ => ser}/compact_integer.rs (95%) create mode 100644 src/ser/mod.rs rename src/{ => ser}/reader.rs (85%) rename src/{ => ser}/stream.rs (83%) diff --git a/src/block.rs b/src/chain/block.rs similarity index 91% rename from src/block.rs rename to src/chain/block.rs index 2e2ada8c..e6c150a4 100644 --- a/src/block.rs +++ b/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; diff --git a/src/block_header.rs b/src/chain/block_header.rs similarity index 94% rename from src/block_header.rs rename to src/chain/block_header.rs index 151c9702..fc541023 100644 --- a/src/block_header.rs +++ b/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] diff --git a/src/merkle_root.rs b/src/chain/merkle_root.rs similarity index 100% rename from src/merkle_root.rs rename to src/chain/merkle_root.rs diff --git a/src/chain/mod.rs b/src/chain/mod.rs new file mode 100644 index 00000000..43cf8912 --- /dev/null +++ b/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 +}; diff --git a/src/transaction.rs b/src/chain/transaction.rs similarity index 97% rename from src/transaction.rs rename to src/chain/transaction.rs index 60fb25d4..3013765b 100644 --- a/src/transaction.rs +++ b/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; diff --git a/src/lib.rs b/src/lib.rs index eea0b908..1326e292 100644 --- a/src/lib.rs +++ b/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; diff --git a/src/net/address.rs b/src/net/address.rs index c26699b7..e058ffd8 100644 --- a/src/net/address.rs +++ b/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; diff --git a/src/net/service.rs b/src/net/service.rs index 66bb58bf..209ef35c 100644 --- a/src/net/service.rs +++ b/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); diff --git a/src/bytes.rs b/src/primitives/bytes.rs similarity index 56% rename from src/bytes.rs rename to src/primitives/bytes.rs index cbd05855..7ddbf6ef 100644 --- a/src/bytes.rs +++ b/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); @@ -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 where Self: Sized { - let len = try!(reader.read::()); - 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(); diff --git a/src/primitives/mod.rs b/src/primitives/mod.rs new file mode 100644 index 00000000..b2ec392a --- /dev/null +++ b/src/primitives/mod.rs @@ -0,0 +1,3 @@ +mod bytes; + +pub use self::bytes::Bytes; diff --git a/src/script/builder.rs b/src/script/builder.rs index a8748742..f52d3e37 100644 --- a/src/script/builder.rs +++ b/src/script/builder.rs @@ -1,4 +1,4 @@ -use bytes::Bytes; +use primitives::Bytes; use script::{Opcode, Script, Num}; #[derive(Default)] diff --git a/src/script/interpreter.rs b/src/script/interpreter.rs index cf309f66..862807da 100644 --- a/src/script/interpreter.rs +++ b/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 diff --git a/src/script/num.rs b/src/script/num.rs index ee08781c..5eb2a414 100644 --- a/src/script/num.rs +++ b/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. diff --git a/src/script/script.rs b/src/script/script.rs index c80ac75c..c44321b5 100644 --- a/src/script/script.rs +++ b/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 diff --git a/src/script/sign.rs b/src/script/sign.rs index bf5506e4..82ed8fc8 100644 --- a/src/script/sign.rs +++ b/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}; diff --git a/src/script/verify.rs b/src/script/verify.rs index 59c39d47..1cce7242 100644 --- a/src/script/verify.rs +++ b/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 }; diff --git a/src/compact_integer.rs b/src/ser/compact_integer.rs similarity index 95% rename from src/compact_integer.rs rename to src/ser/compact_integer.rs index 12c7f32e..239e60d3 100644 --- a/src/compact_integer.rs +++ b/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] diff --git a/src/ser/mod.rs b/src/ser/mod.rs new file mode 100644 index 00000000..a0cff3d7 --- /dev/null +++ b/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}; diff --git a/src/reader.rs b/src/ser/reader.rs similarity index 85% rename from src/reader.rs rename to src/ser/reader.rs index 687d6f79..4e1def6a 100644 --- a/src/reader.rs +++ b/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(buffer: &[u8]) -> Result 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 where Self: Sized { + let len = try!(reader.read::()); + 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::().unwrap_err()); } + + #[test] + fn test_bytes_deserialize() { + let raw = vec![0x02, 0x01, 0x45]; + let expected: Bytes = "0145".into(); + assert_eq!(expected, deserialize(&raw).unwrap()); + } } diff --git a/src/stream.rs b/src/ser/stream.rs similarity index 83% rename from src/stream.rs rename to src/ser/stream.rs index 83407ba4..b59c351b 100644 --- a/src/stream.rs +++ b/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 { 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)); + } + }