all messages types implemented

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;

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<ShortTransactionID>,
+	prefilled_transactions: Vec<PrefilledTransaction>,
+}
+
+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<Self, ReaderError> 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)
+	}
+}

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<Transaction>,
+}
+
+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<Self, ReaderError> where Self: Sized {
+		let block_transactions = BlockTransactions {
+			blockhash: try!(reader.read()),
+			transactions: try!(reader.read_list()),
+		};
+
+		Ok(block_transactions)
+	}
+}

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<usize>,
+}
+
+impl Serializable for BlockTransactionsRequest {
+	fn serialize(&self, stream: &mut Stream) {
+		let indexes: Vec<CompactInteger> = 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<Self, ReaderError> where Self: Sized {
+		let blockhash = try!(reader.read());
+		let indexes: Vec<CompactInteger> = try!(reader.read_list());
+
+		let request = BlockTransactionsRequest {
+			blockhash: blockhash,
+			indexes: indexes.into_iter().map(Into::into).collect(),
+		};
+
+		Ok(request)
+	}
+}

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;

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<Self, ReaderError> where Self: Sized {
+		let compact: CompactInteger = try!(reader.read());
+		let tx = PrefilledTransaction {
+			index: compact.into(),
+			transaction: try!(reader.read()),
+		};
+
+		Ok(tx)
+	}
+}

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<Payload, ReaderError> {
@@ -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); },
 		}
 	}
 }

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<Self, ReaderError> where Self: Sized {
+		let block = BlockTxn {
+			request: try!(reader.read()),
+		};
+
+		Ok(block)
+	}
+}

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<Self, ReaderError> where Self: Sized {
+		let block = CompactBlock {
+			header: try!(reader.read()),
+		};
+
+		Ok(block)
+	}
+}

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<Self, ReaderError> where Self: Sized {
+		let get_block = GetBlockTxn {
+			request: try!(reader.read()),
+		};
+
+		Ok(get_block)
+	}
+}

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 {

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 {

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;

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<Self, ReaderError> where Self: Sized {
+		let send_compact = SendCompact {
+			first: try!(reader.read()),
+			second: try!(reader.read()),
+		};
+
+		Ok(send_compact)
+	}
+}

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);

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);