lib: update bitcoin version

Makes use of the new `V2NetworkMessage` apart of the new `p2p` types
crate.

Author: rustaceanrob

protocol/Cargo.toml

@@ -20,7 +20,9 @@ std = ["bitcoin/std", "bitcoin_hashes/std", "chacha20-poly1305/std", "rand/std",
 # depending on which version of tokio is selected by the caller.
 tokio = { version = "1", default-features = false, optional = true, features = ["io-util"] }
 rand = { version = "0.8.0", default-features = false }
-bitcoin = { version = "0.32.4", default-features = false }
+bitcoin = { git = "https://github.com/rust-bitcoin/rust-bitcoin", default-features = false, rev = "bd450d7be31bb50b6bc33f2417bfb5f0b00191b0" }
+p2p = { package = "bitcoin-p2p-messages",  git = "https://github.com/rust-bitcoin/rust-bitcoin", rev = "bd450d7be31bb50b6bc33f2417bfb5f0b00191b0" }
+
 # Depending on hashes directly for HKDF, can drop this and 
 # use the re-exported version in bitcoin > 0.32.*.
 bitcoin_hashes = { version ="0.15.0", default-features = false }

protocol/src/handshake.rs

@@ -16,6 +16,7 @@ use bitcoin::{
     },
     Network,
 };
+use p2p::NetworkExt;
 use rand::Rng;
 
 use crate::{
@@ -131,7 +132,7 @@ impl Handshake<Initialized> {
     ) -> Result<Self, Error> {
         let mut secret_key_buffer = [0u8; 32];
         rng.fill(&mut secret_key_buffer[..]);
-        let sk = SecretKey::from_slice(&secret_key_buffer)?;
+        let sk = SecretKey::from_byte_array(&secret_key_buffer)?;
         let pk = PublicKey::from_secret_key(curve, &sk);
         let es = ElligatorSwift::from_pubkey(pk);
 
@@ -235,8 +236,8 @@ impl<'a> Handshake<SentKey<'a>> {
         let their_ellswift = ElligatorSwift::from_array(their_key);
 
         // Check for V1 protocol magic bytes
-        if self.network.magic()
-            == bitcoin::p2p::Magic::from_bytes(
+        if self.network.default_network_magic()
+            == p2p::Magic::from_bytes(
                 their_key[..4]
                     .try_into()
                     .expect("64 byte array to have 4 byte prefix"),
@@ -896,17 +897,21 @@ mod tests {
 
         // Create a key that starts with Bitcoin mainnet magic bytes
         let mut v1_key = [0u8; NUM_ELLIGATOR_SWIFT_BYTES];
-        v1_key[..4].copy_from_slice(&Network::Bitcoin.magic().to_bytes());
+        let magic = p2p::Magic::from_params(Network::Bitcoin)
+            .unwrap()
+            .to_bytes();
+        v1_key[..4].copy_from_slice(&magic);
 
         let result = handshake.receive_key(v1_key);
         assert!(matches!(result, Err(Error::V1Protocol)));
 
         // Test with different networks
-        let handshake = Handshake::<Initialized>::new(Network::Testnet, Role::Responder).unwrap();
+        let handshake = Handshake::<Initialized>::new(Network::Signet, Role::Responder).unwrap();
         let handshake = handshake.send_key(None, &mut buffer).unwrap();
 
         let mut v1_testnet_key = [0u8; NUM_ELLIGATOR_SWIFT_BYTES];
-        v1_testnet_key[..4].copy_from_slice(&Network::Testnet.magic().to_bytes());
+        let foo_magic = p2p::Magic::from_params(Network::Signet).unwrap().to_bytes();
+        v1_testnet_key[..4].copy_from_slice(&foo_magic);
 
         let result = handshake.receive_key(v1_testnet_key);
         assert!(matches!(result, Err(Error::V1Protocol)));

protocol/src/lib.rs

@@ -15,7 +15,8 @@
 //!
 //! ```no_run
 //! use bip324::io::{Protocol, Payload};
-//! use bip324::serde::{serialize, deserialize, NetworkMessage};
+//! use bitcoin::consensus::{serialize, deserialize};
+//! use p2p::message::{NetworkMessage, V2NetworkMessage};
 //! use std::net::TcpStream;
 //! use std::io::BufReader;
 //!
@@ -34,12 +35,12 @@
 //!     writer,
 //! )?;
 //!
-//! let ping_msg = NetworkMessage::Ping(0xdeadbeef);
-//! let serialized = serialize(ping_msg);
+//! let ping_msg = V2NetworkMessage::new(NetworkMessage::Ping(0xdeadbeef));
+//! let serialized = serialize(&ping_msg);
 //! protocol.write(&Payload::genuine(serialized))?;
 //!
 //! let response = protocol.read()?;
-//! let response_msg: NetworkMessage = deserialize(&response.contents())?;
+//! let response_msg: V2NetworkMessage = deserialize(&response.contents())?;
 //! # Ok(())
 //! # }
 //! ```
@@ -52,7 +53,8 @@
 //! # async fn main() -> Result<(), Box<dyn std::error::Error>> {
 //! use bip324::futures::Protocol;
 //! use bip324::io::Payload;
-//! use bip324::serde::{serialize, deserialize, NetworkMessage};
+//! use bitcoin::consensus::{deserialize, serialize};
+//! use p2p::message::{NetworkMessage, V2NetworkMessage};
 //! use tokio::net::TcpStream;
 //! use tokio::io::BufReader;
 //!
@@ -70,31 +72,12 @@
 //!     writer,
 //! ).await?;
 //!
-//! let ping_msg = NetworkMessage::Ping(12345); // nonce
-//! let serialized = serialize(ping_msg);
+//! let ping_msg = V2NetworkMessage::new(NetworkMessage::Ping(12345)); // nonce
+//! let serialized = serialize(&ping_msg);
 //! protocol.write(&Payload::genuine(serialized)).await?;
 //!
 //! let response = protocol.read().await?;
-//! let response_msg: NetworkMessage = deserialize(&response.contents())?;
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! # Message Serialization
-//!
-//! BIP-324 introduces specific changes to how bitcoin P2P messages are serialized for V2 transport.
-//! The [`serde`] module provides these serialization functions.
-//!
-//! ```no_run
-//! # #[cfg(feature = "std")]
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! use bip324::serde::{serialize, deserialize, NetworkMessage};
-//!
-//! let ping_msg = NetworkMessage::Ping(0xdeadbeef);
-//! let serialized = serialize(ping_msg);
-//!
-//! let received_bytes = vec![0x12, 0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0];
-//! let message: NetworkMessage = deserialize(&received_bytes)?;
+//! let response_msg: V2NetworkMessage = deserialize(&response.contents())?;
 //! # Ok(())
 //! # }
 //! ```
@@ -148,8 +131,6 @@ pub mod futures;
 mod handshake;
 #[cfg(feature = "std")]
 pub mod io;
-#[cfg(feature = "std")]
-pub mod serde;
 
 use core::fmt;
 
@@ -168,6 +149,7 @@ pub use handshake::{
 };
 
 use fschacha20poly1305::{FSChaCha20, FSChaCha20Poly1305};
+use p2p::NetworkExt;
 
 /// Value for header byte with the decoy flag flipped to true.
 pub const DECOY_BYTE: u8 = 128;
@@ -234,10 +216,10 @@ impl fmt::Display for Error {
                 "Packet size exceeds maximum 4MiB size for automatic allocation."
             ),
             Error::NoGarbageTerminator => {
-                write!(f, "More than 4095 bytes of garbage recieved in the handshake before a terminator was sent.")
+                write!(f, "More than 4095 bytes of garbage received in the handshake before a terminator was sent.")
             }
             Error::SecretGeneration(e) => write!(f, "Cannot generate secrets: {e:?}."),
-            Error::Decryption(e) => write!(f, "Decrytion error: {e:?}."),
+            Error::Decryption(e) => write!(f, "Decryption error: {e:?}."),
             Error::V1Protocol => write!(f, "The remote peer is communicating on the V1 protocol."),
             Error::TooMuchGarbage => write!(
                 f,
@@ -353,7 +335,7 @@ impl SessionKeyMaterial {
         let ecdh_sk = ElligatorSwift::shared_secret(a, b, secret, party, Some(data));
 
         let ikm_salt = "bitcoin_v2_shared_secret".as_bytes();
-        let magic = network.magic().to_bytes();
+        let magic = network.default_network_magic().to_bytes();
         let salt = [ikm_salt, &magic].concat();
         let hk = Hkdf::<sha256::Hash>::new(salt.as_slice(), ecdh_sk.as_secret_bytes());
         let mut session_id = [0u8; 32];
@@ -376,7 +358,7 @@ impl SessionKeyMaterial {
         hk.expand(garbage_info, &mut garbage)?;
         let initiator_garbage_terminator: [u8; 16] = garbage[..16]
             .try_into()
-            .expect("first 16 btyes of expanded garbage");
+            .expect("first 16 bytes of expanded garbage");
         let responder_garbage_terminator: [u8; 16] = garbage[16..]
             .try_into()
             .expect("last 16 bytes of expanded garbage");