From 876c589f5c076e6f169b60df4ccd512ee8099dfb Mon Sep 17 00:00:00 2001 From: debris Date: Tue, 4 Oct 2016 01:48:27 +0200 Subject: [PATCH] all messages types implemented --- chain/src/lib.rs | 4 +- message/src/common/block_header_and_ids.rs | 34 +++++++++++++++++ message/src/common/block_transactions.rs | 28 ++++++++++++++ .../src/common/block_transactions_request.rs | 38 +++++++++++++++++++ message/src/common/mod.rs | 8 ++++ message/src/common/prefilled_transaction.rs | 31 +++++++++++++++ message/src/message/payload.rs | 19 +++++++++- message/src/types/blocktxn.rs | 23 +++++++++++ message/src/types/compactblock.rs | 23 +++++++++++ message/src/types/getblocktxn.rs | 23 +++++++++++ message/src/types/inv.rs | 2 +- .../src => message/src/types}/merkle_block.rs | 2 +- message/src/types/mod.rs | 10 +++++ message/src/types/sendcompact.rs | 26 +++++++++++++ primitives/src/hash.rs | 1 + serialization/src/impls.rs | 3 +- 16 files changed, 269 insertions(+), 6 deletions(-) create mode 100644 message/src/common/block_header_and_ids.rs create mode 100644 message/src/common/block_transactions.rs create mode 100644 message/src/common/block_transactions_request.rs create mode 100644 message/src/common/prefilled_transaction.rs create mode 100644 message/src/types/blocktxn.rs create mode 100644 message/src/types/compactblock.rs create mode 100644 message/src/types/getblocktxn.rs rename {chain/src => message/src/types}/merkle_block.rs (97%) create mode 100644 message/src/types/sendcompact.rs diff --git a/chain/src/lib.rs b/chain/src/lib.rs index 5adbbfd4..9af799bf 100644 --- a/chain/src/lib.rs +++ b/chain/src/lib.rs @@ -6,7 +6,6 @@ extern crate serialization as ser; mod block; mod block_header; mod merkle_root; -mod merkle_block; mod transaction; pub use rustc_serialize::hex; @@ -15,9 +14,10 @@ pub use primitives::{hash, bytes}; pub use self::block::Block; pub use self::block_header::BlockHeader; pub use self::merkle_root::merkle_root; -pub use self::merkle_block::MerkleBlock; pub use self::transaction::{ Transaction, TransactionInput, TransactionOutput, OutPoint, SEQUENCE_LOCKTIME_DISABLE_FLAG, SEQUENCE_FINAL, SEQUENCE_LOCKTIME_TYPE_FLAG, SEQUENCE_LOCKTIME_MASK }; + +pub type ShortTransactionID = hash::H48; diff --git a/message/src/common/block_header_and_ids.rs b/message/src/common/block_header_and_ids.rs new file mode 100644 index 00000000..956fb193 --- /dev/null +++ b/message/src/common/block_header_and_ids.rs @@ -0,0 +1,34 @@ +use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; +use chain::{BlockHeader, ShortTransactionID}; +use common::PrefilledTransaction; + +#[derive(Debug, PartialEq)] +pub struct BlockHeaderAndIDs { + header: BlockHeader, + nonce: u64, + short_ids: Vec, + prefilled_transactions: Vec, +} + +impl Serializable for BlockHeaderAndIDs { + fn serialize(&self, stream: &mut Stream) { + stream + .append(&self.header) + .append(&self.nonce) + .append_list(&self.short_ids) + .append_list(&self.prefilled_transactions); + } +} + +impl Deserializable for BlockHeaderAndIDs { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let header= BlockHeaderAndIDs { + header: try!(reader.read()), + nonce: try!(reader.read()), + short_ids: try!(reader.read_list()), + prefilled_transactions: try!(reader.read_list()), + }; + + Ok(header) + } +} diff --git a/message/src/common/block_transactions.rs b/message/src/common/block_transactions.rs new file mode 100644 index 00000000..247b7d3e --- /dev/null +++ b/message/src/common/block_transactions.rs @@ -0,0 +1,28 @@ +use hash::H256; +use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; +use chain::Transaction; + +#[derive(Debug, PartialEq)] +pub struct BlockTransactions { + blockhash: H256, + transactions: Vec, +} + +impl Serializable for BlockTransactions { + fn serialize(&self, stream: &mut Stream) { + stream + .append(&self.blockhash) + .append_list(&self.transactions); + } +} + +impl Deserializable for BlockTransactions { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let block_transactions = BlockTransactions { + blockhash: try!(reader.read()), + transactions: try!(reader.read_list()), + }; + + Ok(block_transactions) + } +} diff --git a/message/src/common/block_transactions_request.rs b/message/src/common/block_transactions_request.rs new file mode 100644 index 00000000..d6e75127 --- /dev/null +++ b/message/src/common/block_transactions_request.rs @@ -0,0 +1,38 @@ +use hash::H256; +use ser::{ + Serializable, Stream, CompactInteger, + Deserializable, Reader, Error as ReaderError, +}; + +#[derive(Debug, PartialEq)] +pub struct BlockTransactionsRequest { + blockhash: H256, + indexes: Vec, +} + +impl Serializable for BlockTransactionsRequest { + fn serialize(&self, stream: &mut Stream) { + let indexes: Vec = self.indexes + .iter() + .map(|x| (*x).into()) + .collect(); + + stream + .append(&self.blockhash) + .append_list(&indexes); + } +} + +impl Deserializable for BlockTransactionsRequest { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let blockhash = try!(reader.read()); + let indexes: Vec = try!(reader.read_list()); + + let request = BlockTransactionsRequest { + blockhash: blockhash, + indexes: indexes.into_iter().map(Into::into).collect(), + }; + + Ok(request) + } +} diff --git a/message/src/common/mod.rs b/message/src/common/mod.rs index 2d108932..f8d19e02 100644 --- a/message/src/common/mod.rs +++ b/message/src/common/mod.rs @@ -1,17 +1,25 @@ mod address; +mod block_header_and_ids; +mod block_transactions; +mod block_transactions_request; mod command; mod error; mod inventory; mod ip; mod magic; mod port; +mod prefilled_transaction; mod service; pub use self::address::NetAddress; +pub use self::block_header_and_ids::BlockHeaderAndIDs; +pub use self::block_transactions::BlockTransactions; +pub use self::block_transactions_request::BlockTransactionsRequest; pub use self::command::Command; pub use self::error::Error; pub use self::inventory::{InventoryVector, InventoryType}; pub use self::ip::IpAddress; pub use self::magic::Magic; pub use self::port::Port; +pub use self::prefilled_transaction::PrefilledTransaction; pub use self::service::ServiceFlags; diff --git a/message/src/common/prefilled_transaction.rs b/message/src/common/prefilled_transaction.rs new file mode 100644 index 00000000..bbeb0be0 --- /dev/null +++ b/message/src/common/prefilled_transaction.rs @@ -0,0 +1,31 @@ +use ser::{ + Serializable, Stream, CompactInteger, + Deserializable, Reader, Error as ReaderError +}; +use chain::Transaction; + +#[derive(Debug, PartialEq)] +pub struct PrefilledTransaction { + index: usize, + transaction: Transaction, +} + +impl Serializable for PrefilledTransaction { + fn serialize(&self, stream: &mut Stream) { + stream + .append(&CompactInteger::from(self.index)) + .append(&self.transaction); + } +} + +impl Deserializable for PrefilledTransaction { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let compact: CompactInteger = try!(reader.read()); + let tx = PrefilledTransaction { + index: compact.into(), + transaction: try!(reader.read()), + }; + + Ok(tx) + } +} diff --git a/message/src/message/payload.rs b/message/src/message/payload.rs index 8a6d1bd6..b4b87674 100644 --- a/message/src/message/payload.rs +++ b/message/src/message/payload.rs @@ -2,12 +2,13 @@ use ser::{ Serializable, Stream, Error as ReaderError, deserialize }; -use chain::{Transaction, Block, MerkleBlock}; +use chain::{Transaction, Block}; use common::Command; use types::{ Version, Addr, AddrBelow31402, Inv, GetData, NotFound, GetBlocks, GetHeaders, Headers, Ping, Pong, Reject, FilterLoad, FilterAdd, FeeFilter, + MerkleBlock, SendCompact, CompactBlock, GetBlockTxn, BlockTxn, }; pub fn deserialize_payload(data: &[u8], version: u32, command: &Command) -> Result { @@ -37,6 +38,10 @@ pub fn deserialize_payload(data: &[u8], version: u32, command: &Command) -> Resu "merkleblock" => deserialize(data).map(Payload::MerkleBlock), "sendheaders" if data.is_empty() => Ok(Payload::SendHeaders), "feefilter" => deserialize(data).map(Payload::FeeFilter), + "sendcmpct" => deserialize(data).map(Payload::SendCompact), + "cmpctblock" => deserialize(data).map(Payload::CompactBlock), + "getblocktxn" => deserialize(data).map(Payload::GetBlockTxn), + "blocktxn" => deserialize(data).map(Payload::BlockTxn), _ => Err(ReaderError::MalformedData), } } @@ -66,6 +71,10 @@ pub enum Payload { MerkleBlock(MerkleBlock), SendHeaders, FeeFilter(FeeFilter), + SendCompact(SendCompact), + CompactBlock(CompactBlock), + GetBlockTxn(GetBlockTxn), + BlockTxn(BlockTxn), } impl Payload { @@ -93,6 +102,10 @@ impl Payload { Payload::MerkleBlock(_) => "merkleblock", Payload::SendHeaders => "sendheaders", Payload::FeeFilter(_) => "feefilter", + Payload::SendCompact(_) => "sendcmpct", + Payload::CompactBlock(_) => "compactblock", + Payload::GetBlockTxn(_) => "getblocktxn", + Payload::BlockTxn(_) => "blocktxn", }; cmd.into() @@ -126,6 +139,10 @@ impl Serializable for Payload { Payload::MerkleBlock(ref p) => { stream.append(p); }, Payload::SendHeaders => {}, Payload::FeeFilter(ref p) => { stream.append(p); }, + Payload::SendCompact(ref p) => { stream.append(p); }, + Payload::CompactBlock(ref p) => { stream.append(p); }, + Payload::GetBlockTxn(ref p) => { stream.append(p); }, + Payload::BlockTxn(ref p) => { stream.append(p); }, } } } diff --git a/message/src/types/blocktxn.rs b/message/src/types/blocktxn.rs new file mode 100644 index 00000000..9479ec43 --- /dev/null +++ b/message/src/types/blocktxn.rs @@ -0,0 +1,23 @@ +use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; +use common::BlockTransactions; + +#[derive(Debug, PartialEq)] +pub struct BlockTxn { + request: BlockTransactions, +} + +impl Serializable for BlockTxn { + fn serialize(&self, stream: &mut Stream) { + stream.append(&self.request); + } +} + +impl Deserializable for BlockTxn { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let block = BlockTxn { + request: try!(reader.read()), + }; + + Ok(block) + } +} diff --git a/message/src/types/compactblock.rs b/message/src/types/compactblock.rs new file mode 100644 index 00000000..be2669a0 --- /dev/null +++ b/message/src/types/compactblock.rs @@ -0,0 +1,23 @@ +use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; +use common::BlockHeaderAndIDs; + +#[derive(Debug, PartialEq)] +pub struct CompactBlock { + header: BlockHeaderAndIDs, +} + +impl Serializable for CompactBlock { + fn serialize(&self, stream: &mut Stream) { + stream.append(&self.header); + } +} + +impl Deserializable for CompactBlock { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let block = CompactBlock { + header: try!(reader.read()), + }; + + Ok(block) + } +} diff --git a/message/src/types/getblocktxn.rs b/message/src/types/getblocktxn.rs new file mode 100644 index 00000000..c03dafcb --- /dev/null +++ b/message/src/types/getblocktxn.rs @@ -0,0 +1,23 @@ +use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; +use common::BlockTransactionsRequest; + +#[derive(Debug, PartialEq)] +pub struct GetBlockTxn { + request: BlockTransactionsRequest, +} + +impl Serializable for GetBlockTxn { + fn serialize(&self, stream: &mut Stream) { + stream.append(&self.request); + } +} + +impl Deserializable for GetBlockTxn { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let get_block = GetBlockTxn { + request: try!(reader.read()), + }; + + Ok(get_block) + } +} diff --git a/message/src/types/inv.rs b/message/src/types/inv.rs index 926dd901..785bf0e9 100644 --- a/message/src/types/inv.rs +++ b/message/src/types/inv.rs @@ -1,5 +1,5 @@ -use common::InventoryVector; use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; +use common::InventoryVector; #[derive(Debug, PartialEq)] pub struct Inv { diff --git a/chain/src/merkle_block.rs b/message/src/types/merkle_block.rs similarity index 97% rename from chain/src/merkle_block.rs rename to message/src/types/merkle_block.rs index 85111ab8..696ab903 100644 --- a/chain/src/merkle_block.rs +++ b/message/src/types/merkle_block.rs @@ -1,7 +1,7 @@ use hash::H256; use bytes::Bytes; use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; -use BlockHeader; +use chain::BlockHeader; #[derive(Debug, PartialEq)] pub struct MerkleBlock { diff --git a/message/src/types/mod.rs b/message/src/types/mod.rs index c75e7b2f..dedee35e 100644 --- a/message/src/types/mod.rs +++ b/message/src/types/mod.rs @@ -1,23 +1,33 @@ mod addr; +mod blocktxn; +mod compactblock; mod feefilter; mod filterload; mod filteradd; mod getblocks; +mod getblocktxn; mod headers; mod inv; +mod merkle_block; mod ping; pub mod reject; +mod sendcompact; pub mod version; pub use self::addr::{Addr, AddrBelow31402}; +pub use self::blocktxn::BlockTxn; +pub use self::compactblock::CompactBlock; pub use self::feefilter::FeeFilter; pub use self::filterload::FilterLoad; pub use self::filteradd::FilterAdd; pub use self::getblocks::GetBlocks; +pub use self::getblocktxn::GetBlockTxn; pub use self::headers::Headers; pub use self::inv::Inv; +pub use self::merkle_block::MerkleBlock; pub use self::ping::Ping; pub use self::reject::Reject; +pub use self::sendcompact::SendCompact; pub use self::version::Version; pub type GetData = Inv; diff --git a/message/src/types/sendcompact.rs b/message/src/types/sendcompact.rs new file mode 100644 index 00000000..4987775f --- /dev/null +++ b/message/src/types/sendcompact.rs @@ -0,0 +1,26 @@ +use ser::{Serializable, Stream, Deserializable, Reader, Error as ReaderError}; + +#[derive(Debug, PartialEq)] +pub struct SendCompact { + first: bool, + second: u64, +} + +impl Serializable for SendCompact { + fn serialize(&self, stream: &mut Stream) { + stream + .append(&self.first) + .append(&self.second); + } +} + +impl Deserializable for SendCompact { + fn deserialize(reader: &mut Reader) -> Result where Self: Sized { + let send_compact = SendCompact { + first: try!(reader.read()), + second: try!(reader.read()), + }; + + Ok(send_compact) + } +} diff --git a/primitives/src/hash.rs b/primitives/src/hash.rs index 049ca709..002b5de7 100644 --- a/primitives/src/hash.rs +++ b/primitives/src/hash.rs @@ -106,6 +106,7 @@ macro_rules! impl_hash { } } +impl_hash!(H48, 6); impl_hash!(H96, 12); impl_hash!(H160, 20); impl_hash!(H256, 32); diff --git a/serialization/src/impls.rs b/serialization/src/impls.rs index 4318f704..e678550e 100644 --- a/serialization/src/impls.rs +++ b/serialization/src/impls.rs @@ -1,6 +1,6 @@ use bytes::Bytes; use byteorder::{ReadBytesExt, WriteBytesExt, LittleEndian}; -use hash::{H96, H160, H256, H264, H512, H520}; +use hash::{H48, H96, H160, H256, H264, H512, H520}; use compact_integer::CompactInteger; use {Serializable, Stream, Deserializable, Reader, Error}; @@ -142,6 +142,7 @@ macro_rules! impl_ser_for_hash { } } +impl_ser_for_hash!(H48, 6); impl_ser_for_hash!(H96, 12); impl_ser_for_hash!(H160, 20); impl_ser_for_hash!(H256, 32);