Add BIP152 (Compact Blocks) structures

src/blockdata/block.rs

@@ -39,7 +39,7 @@ use VarInt;
 
 /// A block header, which contains all the block's information except
 /// the actual transactions
-#[derive(Copy, PartialEq, Eq, Clone, Debug)]
+#[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct BlockHeader {
     /// The protocol version. Should always be 1.

src/consensus/encode.rs

@@ -523,6 +523,7 @@ macro_rules! impl_array {
 
 impl_array!(2);
 impl_array!(4);
+impl_array!(6);
 impl_array!(8);
 impl_array!(10);
 impl_array!(12);
@@ -596,6 +597,9 @@ impl_vec!(TxIn);
 impl_vec!(Vec<u8>);
 impl_vec!(u64);
 impl_vec!(TapLeafHash);
+impl_vec!(VarInt);
+impl_vec!(::util::bip152::ShortId);
+impl_vec!(::util::bip152::PrefilledTransaction);
 
 #[cfg(feature = "std")] impl_vec!(Inventory);
 #[cfg(feature = "std")] impl_vec!((u32, Address));

src/network/message.rs

@@ -28,6 +28,7 @@ use blockdata::transaction;
 use network::address::{Address, AddrV2Message};
 use network::{message_network, message_bloom};
 use network::message_blockdata;
+use network::message_compact_blocks;
 use network::message_filter;
 use consensus::encode::{CheckedData, Decodable, Encodable, VarInt, MAX_VEC_SIZE};
 use consensus::{encode, serialize};
@@ -186,6 +187,14 @@ pub enum NetworkMessage {
     GetCFCheckpt(message_filter::GetCFCheckpt),
     /// BIP157 cfcheckpt
     CFCheckpt(message_filter::CFCheckpt),
+    /// BIP152 sendcmpct
+    SendCmpct(message_compact_blocks::SendCmpct),
+    /// BIP152 cmpctblock
+    CmpctBlock(message_compact_blocks::CmpctBlock),
+    /// BIP152 getblocktxn
+    GetBlockTxn(message_compact_blocks::GetBlockTxn),
+    /// BIP152 blocktxn
+    BlockTxn(message_compact_blocks::BlockTxn),
     /// `alert`
     Alert(Vec<u8>),
     /// `reject`
@@ -242,6 +251,10 @@ impl NetworkMessage {
             NetworkMessage::CFHeaders(_) => "cfheaders",
             NetworkMessage::GetCFCheckpt(_) => "getcfcheckpt",
             NetworkMessage::CFCheckpt(_) => "cfcheckpt",
+            NetworkMessage::SendCmpct(_) => "sendcmpct",
+            NetworkMessage::CmpctBlock(_) => "cmpctblock",
+            NetworkMessage::GetBlockTxn(_) => "getblocktxn",
+            NetworkMessage::BlockTxn(_) => "blocktxn",
             NetworkMessage::Alert(_)    => "alert",
             NetworkMessage::Reject(_)    => "reject",
             NetworkMessage::FeeFilter(_) => "feefilter",
@@ -325,6 +338,10 @@ impl Encodable for RawNetworkMessage {
             NetworkMessage::CFHeaders(ref dat) => serialize(dat),
             NetworkMessage::GetCFCheckpt(ref dat) => serialize(dat),
             NetworkMessage::CFCheckpt(ref dat) => serialize(dat),
+            NetworkMessage::SendCmpct(ref dat) => serialize(dat),
+            NetworkMessage::CmpctBlock(ref dat) => serialize(dat),
+            NetworkMessage::GetBlockTxn(ref dat) => serialize(dat),
+            NetworkMessage::BlockTxn(ref dat) => serialize(dat),
             NetworkMessage::Alert(ref dat)    => serialize(dat),
             NetworkMessage::Reject(ref dat) => serialize(dat),
             NetworkMessage::FeeFilter(ref data) => serialize(data),
@@ -402,6 +419,10 @@ impl Decodable for RawNetworkMessage {
             "getcfcheckpt" => NetworkMessage::GetCFCheckpt(Decodable::consensus_decode(&mut mem_d)?),
             "cfcheckpt" => NetworkMessage::CFCheckpt(Decodable::consensus_decode(&mut mem_d)?),
             "reject" => NetworkMessage::Reject(Decodable::consensus_decode(&mut mem_d)?),
+            "sendcmpct" => NetworkMessage::SendCmpct(Decodable::consensus_decode(&mut mem_d)?),
+            "cmpctblock" => NetworkMessage::CmpctBlock(Decodable::consensus_decode(&mut mem_d)?),
+            "getblocktxn" => NetworkMessage::GetBlockTxn(Decodable::consensus_decode(&mut mem_d)?),
+            "blocktxn" => NetworkMessage::BlockTxn(Decodable::consensus_decode(&mut mem_d)?),
             "alert"   => NetworkMessage::Alert(Decodable::consensus_decode(&mut mem_d)?),
             "feefilter" => NetworkMessage::FeeFilter(Decodable::consensus_decode(&mut mem_d)?),
             "wtxidrelay" => NetworkMessage::WtxidRelay,

src/network/message_blockdata.rs

@@ -37,6 +37,8 @@ pub enum Inventory {
     Transaction(Txid),
     /// Block
     Block(BlockHash),
+    /// Compact Block
+    CompactBlock(BlockHash),
     /// Witness Transaction by Wtxid
     WTx(Wtxid),
     /// Witness Transaction
@@ -68,6 +70,7 @@ impl Encodable for Inventory {
             Inventory::Error => encode_inv!(0, sha256d::Hash::default()),
             Inventory::Transaction(ref t) => encode_inv!(1, t),
             Inventory::Block(ref b) => encode_inv!(2, b),
+            Inventory::CompactBlock(ref b) => encode_inv!(4, b),
             Inventory::WTx(w) => encode_inv!(5, w),
             Inventory::WitnessTransaction(ref t) => encode_inv!(0x40000001, t),
             Inventory::WitnessBlock(ref b) => encode_inv!(0x40000002, b),
@@ -84,6 +87,7 @@ impl Decodable for Inventory {
             0 => Inventory::Error,
             1 => Inventory::Transaction(Decodable::consensus_decode(&mut d)?),
             2 => Inventory::Block(Decodable::consensus_decode(&mut d)?),
+            4 => Inventory::CompactBlock(Decodable::consensus_decode(&mut d)?),
             5 => Inventory::WTx(Decodable::consensus_decode(&mut d)?),
             0x40000001 => Inventory::WitnessTransaction(Decodable::consensus_decode(&mut d)?),
             0x40000002 => Inventory::WitnessBlock(Decodable::consensus_decode(&mut d)?),

src/network/message_compact_blocks.rs

@@ -0,0 +1,44 @@
+//!
+//! BIP152  Compact Blocks network messages
+//!
+
+use util::bip152;
+
+/// sendcmpct message
+#[derive(PartialEq, Eq, Clone, Debug, Copy, PartialOrd, Ord, Hash)]
+pub struct SendCmpct {
+    /// Request to be send compact blocks.
+    pub send_compact: bool,
+    /// Compact Blocks protocol version number.
+    pub version: u64,
+}
+impl_consensus_encoding!(SendCmpct, send_compact, version);
+
+/// cmpctblock message
+///
+/// Note that the rules for validation before relaying compact blocks is
+/// different from headers and regular block messages. Thus, you shouldn't use
+/// compact blocks when relying on an upstream full node to have validated data
+/// being forwarded to you.
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct CmpctBlock {
+    /// The Compact Block.
+    pub compact_block: bip152::HeaderAndShortIds,
+}
+impl_consensus_encoding!(CmpctBlock, compact_block);
+
+/// getblocktxn message
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct GetBlockTxn {
+    /// The block transactions request.
+    pub txs_request: bip152::BlockTransactionsRequest,
+}
+impl_consensus_encoding!(GetBlockTxn, txs_request);
+
+/// blocktxn message
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct BlockTxn {
+    /// The requested block transactions.
+    pub transactions: bip152::BlockTransactions,
+}
+impl_consensus_encoding!(BlockTxn, transactions);

src/network/mod.rs

@@ -41,6 +41,9 @@ pub mod message_blockdata;
 pub mod message_bloom;
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub mod message_compact_blocks;
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 pub mod message_network;
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]