Move bip152 to p2p

Replaces rust-bitcoin#5333 and rust-bitcoin#5365 by manually implementing `hex` traits for the
`ShortId` type. `FromStr` is omitted as I can't think of a logical use
of that method in this context. To make any sense of a string short ID
one needs the nonce and siphash keys.

This module is only relevant between two peers relaying blocks over the
peer to peer network.

Author: rustaceanrob

bitcoin/src/lib.rs

@@ -116,7 +116,6 @@ pub mod ext {
 }
 #[macro_use]
 pub mod address;
-pub mod bip152;
 pub mod bip158;
 pub mod bip32;
 pub mod blockdata;

fuzz/fuzz_targets/bitcoin/deserialize_prefilled_transaction.rs

@@ -2,7 +2,7 @@ use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     // We already fuzz Transactions in `./deserialize_transaction.rs`.
-    let tx_result: Result<bitcoin::bip152::PrefilledTransaction, _> =
+    let tx_result: Result<p2p::bip152::PrefilledTransaction, _> =
         bitcoin::consensus::encode::deserialize(data);
 
     match tx_result {

bitcoin/src/bip152.rs p2p/src/bip152.rsbitcoin/src/bip152.rs renamed to p2p/src/bip152.rs

@@ -4,6 +4,7 @@
 //!
 //! Implementation of compact blocks data structure and algorithms.
 
+use alloc::vec::Vec;
 use core::convert::Infallible;
 use core::{convert, fmt, mem};
 #[cfg(feature = "std")]
@@ -16,11 +17,9 @@ use internals::array::ArrayExt as _;
 use internals::ToU64 as _;
 use io::{BufRead, Write};
 
-use crate::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
-use crate::internal_macros::{self, impl_array_newtype_stringify};
-use crate::prelude::Vec;
-use crate::transaction::TxIdentifier;
-use crate::{block, consensus, Block, BlockChecked, BlockHash, Transaction};
+use bitcoin::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
+use bitcoin::transaction::TxIdentifier;
+use bitcoin::{block, Block, BlockChecked, BlockHash, Transaction};
 
 /// A BIP-0152 error
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -89,7 +88,7 @@ impl Decodable for PrefilledTransaction {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         let idx = r.read_compact_size()?;
         let idx = u16::try_from(idx).map_err(|_| {
-            consensus::parse_failed_error("BIP-0152 prefilled tx index out of bounds")
+            crate::consensus::parse_failed_error("BIP-0152 prefilled tx index out of bounds")
         })?;
         let tx = Transaction::consensus_decode(r)?;
         Ok(Self { idx, tx })
@@ -100,7 +99,6 @@ impl Decodable for PrefilledTransaction {
 #[derive(PartialEq, Eq, Clone, Copy, Hash, Default, PartialOrd, Ord)]
 pub struct ShortId([u8; 6]);
 internals::impl_array_newtype!(ShortId, u8, 6);
-impl_array_newtype_stringify!(ShortId, 6);
 
 impl ShortId {
     /// Calculates the SipHash24 keys used to calculate short IDs.
@@ -134,6 +132,30 @@ impl ShortId {
     }
 }
 
+impl core::fmt::LowerHex for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        hex::display::fmt_hex_exact!(f, 6, &self.0, hex::Case::Lower)
+    }
+}
+
+impl core::fmt::UpperHex for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        hex::display::fmt_hex_exact!(f, 6, &self.0, hex::Case::Upper)
+    }
+}
+
+impl core::fmt::Display for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl core::fmt::Debug for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::LowerHex::fmt(self, f)
+    }
+}
+
 impl Encodable for ShortId {
     #[inline]
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
@@ -177,7 +199,7 @@ impl Decodable for HeaderAndShortIds {
         };
         match header_short_ids.short_ids.len().checked_add(header_short_ids.prefilled_txs.len()) {
             Some(x) if x <= u16::MAX.into() => Ok(header_short_ids),
-            _ => Err(consensus::parse_failed_error("indexes overflowed 16 bits")),
+            _ => Err(crate::consensus::parse_failed_error("indexes overflowed 16 bits")),
         }
     }
 }
@@ -313,7 +335,7 @@ impl Decodable for BlockTransactionsRequest {
                 // transactions that would be allowed in a vector.
                 let byte_size = nb_indexes
                     .checked_mul(mem::size_of::<Transaction>())
-                    .ok_or(consensus::parse_failed_error("invalid length"))?;
+                    .ok_or(crate::consensus::parse_failed_error("invalid length"))?;
                 if byte_size > encode::MAX_VEC_SIZE {
                     return Err(encode::ParseError::OversizedVectorAllocation {
                         requested: byte_size,
@@ -328,12 +350,12 @@ impl Decodable for BlockTransactionsRequest {
                     let differential = r.read_compact_size()?;
                     last_index = match last_index.checked_add(differential) {
                         Some(i) => i,
-                        None => return Err(consensus::parse_failed_error("block index overflow")),
+                        None => return Err(crate::consensus::parse_failed_error("block index overflow")),
                     };
                     indexes.push(last_index);
                     last_index = match last_index.checked_add(1) {
                         Some(i) => i,
-                        None => return Err(consensus::parse_failed_error("block index overflow")),
+                        None => return Err(crate::consensus::parse_failed_error("block index overflow")),
                     };
                 }
                 indexes
@@ -373,7 +395,7 @@ pub struct BlockTransactions {
     ///  The transactions provided.
     pub transactions: Vec<Transaction>,
 }
-internal_macros::impl_consensus_encoding!(BlockTransactions, block_hash, transactions);
+crate::consensus::impl_consensus_encoding!(BlockTransactions, block_hash, transactions);
 
 impl BlockTransactions {
     /// Constructs a new [`BlockTransactions`] from a [`BlockTransactionsRequest`] and
@@ -446,14 +468,15 @@ impl<'a> Arbitrary<'a> for BlockTransactionsRequest {
 
 #[cfg(test)]
 mod test {
+    use alloc::vec;
     use hex::FromHex;
 
     use super::*;
-    use crate::consensus::encode::{deserialize, serialize};
-    use crate::locktime::absolute;
-    use crate::merkle_tree::TxMerkleNode;
-    use crate::transaction::OutPointExt;
-    use crate::{
+    use bitcoin::consensus::encode::{deserialize, serialize};
+    use bitcoin::locktime::absolute;
+    use bitcoin::merkle_tree::TxMerkleNode;
+    use bitcoin::transaction::OutPointExt;
+    use bitcoin::{
         transaction, Amount, BlockChecked, BlockTime, CompactTarget, OutPoint, ScriptPubKeyBuf,
         ScriptSigBuf, Sequence, TxIn, TxOut, Txid, Witness,
     };

p2p/src/lib.rs

@@ -19,6 +19,7 @@ mod network_ext;
 
 #[cfg(feature = "std")]
 pub mod address;
+pub mod bip152;
 #[cfg(feature = "std")]
 pub mod message;
 pub mod message_blockdata;

p2p/src/message.rs

@@ -956,7 +956,6 @@ mod test {
     use alloc::vec;
     use std::net::Ipv4Addr;
 
-    use bitcoin::bip152::BlockTransactionsRequest;
     use bitcoin::bip158::{FilterHash, FilterHeader};
     use bitcoin::block::{Block, BlockHash};
     use bitcoin::consensus::encode::{deserialize, deserialize_partial, serialize};
@@ -966,6 +965,7 @@ mod test {
 
     use super::*;
     use crate::address::AddrV2;
+    use crate::bip152::BlockTransactionsRequest;
     use crate::message_blockdata::{GetBlocksMessage, GetHeadersMessage, Inventory};
     use crate::message_bloom::{BloomFlags, FilterAdd, FilterLoad};
     use crate::message_compact_blocks::{GetBlockTxn, SendCmpct};

p2p/src/message_compact_blocks.rs

@@ -5,8 +5,8 @@
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
-use bitcoin::bip152;
 
+use crate::bip152;
 use crate::consensus::impl_consensus_encoding;
 
 /// sendcmpct message