p2p: add clippy::use_self lint

diff --git a/p2p/Cargo.toml b/p2p/Cargo.toml
index 40669b96..42d28596 100644
--- a/p2p/Cargo.toml
+++ b/p2p/Cargo.toml
@@ -37,3 +37,6 @@ required-features = ["std"]
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.clippy]
+use_self = "warn"
diff --git a/p2p/src/address.rs b/p2p/src/address.rs
index a9cb782e..d03ef9dc 100644
--- a/p2p/src/address.rs
+++ b/p2p/src/address.rs
@@ -32,18 +32,18 @@ const ONION: [u16; 3] = [0xFD87, 0xD87E, 0xEB43];
 
 impl Address {
     /// Constructs a new address message for a socket
-    pub fn new(socket: &SocketAddr, services: ServiceFlags) -> Address {
+    pub fn new(socket: &SocketAddr, services: ServiceFlags) -> Self {
         let (address, port) = match *socket {
             SocketAddr::V4(addr) => (addr.ip().to_ipv6_mapped().segments(), addr.port()),
             SocketAddr::V6(addr) => (addr.ip().segments(), addr.port()),
         };
-        Address { address, port, services }
+        Self { address, port, services }
     }
 
     /// Builds a useless address that cannot be connected to. One may find this desirable if it is
     /// known the data will be ignored by the recipient.
-    pub const fn useless() -> Address {
-        Address { services: ServiceFlags::NONE, address: [0; 8], port: 0 }
+    pub const fn useless() -> Self {
+        Self { services: ServiceFlags::NONE, address: [0; 8], port: 0 }
     }
 
     /// Extracts socket address from an [Address] message.
@@ -84,7 +84,7 @@ impl Encodable for Address {
 impl Decodable for Address {
     #[inline]
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(Address {
+        Ok(Self {
             services: Decodable::consensus_decode(r)?,
             address: read_be_address(r)?,
             port: u16::swap_bytes(Decodable::consensus_decode(r)?),
@@ -150,10 +150,10 @@ pub enum AddrV2 {
 impl TryFrom<AddrV2> for IpAddr {
     type Error = AddrV2ToIpAddrError;
 
-    fn try_from(addr: AddrV2) -> Result<IpAddr, Self::Error> {
+    fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
         match addr {
-            AddrV2::Ipv4(ip) => Ok(IpAddr::V4(ip)),
-            AddrV2::Ipv6(ip) => Ok(IpAddr::V6(ip)),
+            AddrV2::Ipv4(ip) => Ok(Self::V4(ip)),
+            AddrV2::Ipv6(ip) => Ok(Self::V6(ip)),
             AddrV2::Cjdns(_) => Err(AddrV2ToIpAddrError::Cjdns),
             AddrV2::TorV3(_) => Err(AddrV2ToIpAddrError::TorV3),
             AddrV2::I2p(_) => Err(AddrV2ToIpAddrError::I2p),
@@ -165,7 +165,7 @@ impl TryFrom<AddrV2> for IpAddr {
 impl TryFrom<AddrV2> for Ipv4Addr {
     type Error = AddrV2ToIpv4AddrError;
 
-    fn try_from(addr: AddrV2) -> Result<Ipv4Addr, Self::Error> {
+    fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
         match addr {
             AddrV2::Ipv4(ip) => Ok(ip),
             AddrV2::Ipv6(_) => Err(AddrV2ToIpv4AddrError::Ipv6),
@@ -180,7 +180,7 @@ impl TryFrom<AddrV2> for Ipv4Addr {
 impl TryFrom<AddrV2> for Ipv6Addr {
     type Error = AddrV2ToIpv6AddrError;
 
-    fn try_from(addr: AddrV2) -> Result<Ipv6Addr, Self::Error> {
+    fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
         match addr {
             AddrV2::Ipv6(ip) => Ok(ip),
             AddrV2::Cjdns(_) => Err(AddrV2ToIpv6AddrError::Cjdns),
@@ -195,18 +195,18 @@ impl TryFrom<AddrV2> for Ipv6Addr {
 impl From<IpAddr> for AddrV2 {
     fn from(addr: IpAddr) -> Self {
         match addr {
-            IpAddr::V4(ip) => AddrV2::Ipv4(ip),
-            IpAddr::V6(ip) => AddrV2::Ipv6(ip),
+            IpAddr::V4(ip) => Self::Ipv4(ip),
+            IpAddr::V6(ip) => Self::Ipv6(ip),
         }
     }
 }
 
 impl From<Ipv4Addr> for AddrV2 {
-    fn from(addr: Ipv4Addr) -> Self { AddrV2::Ipv4(addr) }
+    fn from(addr: Ipv4Addr) -> Self { Self::Ipv4(addr) }
 }
 
 impl From<Ipv6Addr> for AddrV2 {
-    fn from(addr: Ipv6Addr) -> Self { AddrV2::Ipv6(addr) }
+    fn from(addr: Ipv6Addr) -> Self { Self::Ipv6(addr) }
 }
 
 impl Encodable for AddrV2 {
@@ -220,12 +220,12 @@ impl Encodable for AddrV2 {
                 + crate::consensus::consensus_encode_with_size(bytes, w)?)
         }
         Ok(match *self {
-            AddrV2::Ipv4(ref addr) => encode_addr(w, 1, &addr.octets())?,
-            AddrV2::Ipv6(ref addr) => encode_addr(w, 2, &addr.octets())?,
-            AddrV2::TorV3(ref bytes) => encode_addr(w, 4, bytes)?,
-            AddrV2::I2p(ref bytes) => encode_addr(w, 5, bytes)?,
-            AddrV2::Cjdns(ref addr) => encode_addr(w, 6, &addr.octets())?,
-            AddrV2::Unknown(network, ref bytes) => encode_addr(w, network, bytes)?,
+            Self::Ipv4(ref addr) => encode_addr(w, 1, &addr.octets())?,
+            Self::Ipv6(ref addr) => encode_addr(w, 2, &addr.octets())?,
+            Self::TorV3(ref bytes) => encode_addr(w, 4, bytes)?,
+            Self::I2p(ref bytes) => encode_addr(w, 5, bytes)?,
+            Self::Cjdns(ref addr) => encode_addr(w, 6, &addr.octets())?,
+            Self::Unknown(network, ref bytes) => encode_addr(w, network, bytes)?,
         })
     }
 }
@@ -243,7 +243,7 @@ impl Decodable for AddrV2 {
                     return Err(crate::consensus::parse_failed_error("invalid IPv4 address"));
                 }
                 let addr: [u8; 4] = Decodable::consensus_decode(r)?;
-                AddrV2::Ipv4(Ipv4Addr::new(addr[0], addr[1], addr[2], addr[3]))
+                Self::Ipv4(Ipv4Addr::new(addr[0], addr[1], addr[2], addr[3]))
             }
             2 => {
                 if len != 16 {
@@ -260,7 +260,7 @@ impl Decodable for AddrV2 {
                         "IPV4 wrapped address sent with IPv6 network id",
                     ));
                 }
-                AddrV2::Ipv6(Ipv6Addr::new(
+                Self::Ipv6(Ipv6Addr::new(
                     addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
                 ))
             }
@@ -270,14 +270,14 @@ impl Decodable for AddrV2 {
                     return Err(crate::consensus::parse_failed_error("invalid TorV3 address"));
                 }
                 let pubkey = Decodable::consensus_decode(r)?;
-                AddrV2::TorV3(pubkey)
+                Self::TorV3(pubkey)
             }
             5 => {
                 if len != 32 {
                     return Err(crate::consensus::parse_failed_error("invalid I2P address"));
                 }
                 let hash = Decodable::consensus_decode(r)?;
-                AddrV2::I2p(hash)
+                Self::I2p(hash)
             }
             6 => {
                 if len != 16 {
@@ -288,7 +288,7 @@ impl Decodable for AddrV2 {
                 if addr[0] >> 8 != 0xFC {
                     return Err(crate::consensus::parse_failed_error("invalid CJDNS address"));
                 }
-                AddrV2::Cjdns(Ipv6Addr::new(
+                Self::Cjdns(Ipv6Addr::new(
                     addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
                 ))
             }
@@ -296,7 +296,7 @@ impl Decodable for AddrV2 {
                 // len already checked above to be <= 512
                 let mut addr = vec![0u8; len as usize];
                 r.read_slice(&mut addr)?;
-                AddrV2::Unknown(network_id, addr)
+                Self::Unknown(network_id, addr)
             }
         })
     }
@@ -344,7 +344,7 @@ impl Encodable for AddrV2Message {
 
 impl Decodable for AddrV2Message {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(AddrV2Message {
+        Ok(Self {
             time: Decodable::consensus_decode(r)?,
             services: ServiceFlags::from(r.read_compact_size()?),
             addr: Decodable::consensus_decode(r)?,
@@ -472,20 +472,20 @@ impl<'a> Arbitrary<'a> for Address {
             ),
         };
 
-        Ok(Address::new(&socket_addr, u.arbitrary()?))
+        Ok(Self::new(&socket_addr, u.arbitrary()?))
     }
 }
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for AddrV2 {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         match u.int_in_range(0..=5)? {
-            0 => Ok(AddrV2::Ipv4(Ipv4Addr::new(
+            0 => Ok(Self::Ipv4(Ipv4Addr::new(
                 u.arbitrary()?,
                 u.arbitrary()?,
                 u.arbitrary()?,
                 u.arbitrary()?,
             ))),
-            1 => Ok(AddrV2::Ipv6(Ipv6Addr::new(
+            1 => Ok(Self::Ipv6(Ipv6Addr::new(
                 u.arbitrary()?,
                 u.arbitrary()?,
                 u.arbitrary()?,
@@ -495,9 +495,9 @@ impl<'a> Arbitrary<'a> for AddrV2 {
                 u.arbitrary()?,
                 u.arbitrary()?,
             ))),
-            2 => Ok(AddrV2::TorV3(u.arbitrary()?)),
-            3 => Ok(AddrV2::I2p(u.arbitrary()?)),
-            4 => Ok(AddrV2::Cjdns(Ipv6Addr::new(
+            2 => Ok(Self::TorV3(u.arbitrary()?)),
+            3 => Ok(Self::I2p(u.arbitrary()?)),
+            4 => Ok(Self::Cjdns(Ipv6Addr::new(
                 u.arbitrary()?,
                 u.arbitrary()?,
                 u.arbitrary()?,
@@ -507,7 +507,7 @@ impl<'a> Arbitrary<'a> for AddrV2 {
                 u.arbitrary()?,
                 u.arbitrary()?,
             ))),
-            _ => Ok(AddrV2::Unknown(u.arbitrary()?, Vec::<u8>::arbitrary(u)?)),
+            _ => Ok(Self::Unknown(u.arbitrary()?, Vec::<u8>::arbitrary(u)?)),
         }
     }
 }
@@ -515,7 +515,7 @@ impl<'a> Arbitrary<'a> for AddrV2 {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for AddrV2Message {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(AddrV2Message {
+        Ok(Self {
             time: u.arbitrary()?,
             services: u.arbitrary()?,
             addr: u.arbitrary()?,
diff --git a/p2p/src/lib.rs b/p2p/src/lib.rs
index c3dc2fd5..6d9b723e 100644
--- a/p2p/src/lib.rs
+++ b/p2p/src/lib.rs
@@ -77,19 +77,19 @@ pub struct ProtocolVersion(u32);
 
 impl ProtocolVersion {
     /// Support receiving `wtxidrelay` message between `version` and `verack` message
-    pub const WTXID_RELAY_VERSION: ProtocolVersion = ProtocolVersion(70016);
+    pub const WTXID_RELAY_VERSION: Self = Self(70016);
     /// Support receiving invalid compact blocks from a peer without banning them
-    pub const INVALID_CB_NO_BAN_VERSION: ProtocolVersion = ProtocolVersion(70015);
+    pub const INVALID_CB_NO_BAN_VERSION: Self = Self(70015);
     /// Support compact block messages `sendcmpct`, `cmpctblock`, `getblocktxn` and `blocktxn`
-    pub const SHORT_IDS_BLOCKS_VERSION: ProtocolVersion = ProtocolVersion(70014);
+    pub const SHORT_IDS_BLOCKS_VERSION: Self = Self(70014);
     /// Support `feefilter` message
-    pub const FEEFILTER_VERSION: ProtocolVersion = ProtocolVersion(70013);
+    pub const FEEFILTER_VERSION: Self = Self(70013);
     /// Support `sendheaders` message and announce new blocks via headers rather than inv
-    pub const SENDHEADERS_VERSION: ProtocolVersion = ProtocolVersion(70012);
+    pub const SENDHEADERS_VERSION: Self = Self(70012);
     /// Support `pong` message and nonce in `ping` message
-    pub const BIP0031_VERSION: ProtocolVersion = ProtocolVersion(60001);
+    pub const BIP0031_VERSION: Self = Self(60001);
     /// All connections will be terminated below this version.
-    pub const MIN_PEER_PROTO_VERSION: ProtocolVersion = ProtocolVersion(31800);
+    pub const MIN_PEER_PROTO_VERSION: Self = Self(31800);
 }
 
 impl ProtocolVersion {
@@ -111,7 +111,7 @@ impl Encodable for ProtocolVersion {
 impl Decodable for ProtocolVersion {
     #[inline]
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(ProtocolVersion(Decodable::consensus_decode(r)?))
+        Ok(Self(Decodable::consensus_decode(r)?))
     }
 }
 
@@ -121,39 +121,39 @@ pub struct ServiceFlags(u64);
 
 impl ServiceFlags {
     /// NONE means no services supported.
-    pub const NONE: ServiceFlags = ServiceFlags(0);
+    pub const NONE: Self = Self(0);
 
     /// NETWORK means that the node is capable of serving the complete block chain. It is currently
     /// set by all Bitcoin Core non pruned nodes, and is unset by SPV clients or other light
     /// clients.
-    pub const NETWORK: ServiceFlags = ServiceFlags(1 << 0);
+    pub const NETWORK: Self = Self(1 << 0);
 
     /// GETUTXO means the node is capable of responding to the getutxo protocol request. Bitcoin
     /// Core does not support this but a patch set called Bitcoin XT does.
     /// See BIP-0064 for details on how this is implemented.
-    pub const GETUTXO: ServiceFlags = ServiceFlags(1 << 1);
+    pub const GETUTXO: Self = Self(1 << 1);
 
     /// BLOOM means the node is capable and willing to handle bloom-filtered connections. Bitcoin
     /// Core nodes used to support this by default, without advertising this bit, but no longer do
     /// as of protocol version 70011 (= NO_BLOOM_VERSION)
-    pub const BLOOM: ServiceFlags = ServiceFlags(1 << 2);
+    pub const BLOOM: Self = Self(1 << 2);
 
     /// WITNESS indicates that a node can be asked for blocks and transactions including witness
     /// data.
-    pub const WITNESS: ServiceFlags = ServiceFlags(1 << 3);
+    pub const WITNESS: Self = Self(1 << 3);
 
     /// COMPACT_FILTERS means the node will service basic block filter requests.
     /// See BIP-0157 and BIP-0158 for details on how this is implemented.
-    pub const COMPACT_FILTERS: ServiceFlags = ServiceFlags(1 << 6);
+    pub const COMPACT_FILTERS: Self = Self(1 << 6);
 
     /// NETWORK_LIMITED means the same as NODE_NETWORK with the limitation of only serving the last
     /// 288 (2 day) blocks.
     /// See BIP-0159 for details on how this is implemented.
-    pub const NETWORK_LIMITED: ServiceFlags = ServiceFlags(1 << 10);
+    pub const NETWORK_LIMITED: Self = Self(1 << 10);
 
     /// P2P_V2 indicates that the node supports the P2P v2 encrypted transport protocol.
     /// See BIP-0324 for details on how this is implemented.
-    pub const P2P_V2: ServiceFlags = ServiceFlags(1 << 11);
+    pub const P2P_V2: Self = Self(1 << 11);
 
     // NOTE: When adding new flags, remember to update the Display impl accordingly.
 
@@ -161,7 +161,7 @@ impl ServiceFlags {
     ///
     /// Returns itself.
     #[must_use]
-    pub fn add(&mut self, other: ServiceFlags) -> ServiceFlags {
+    pub fn add(&mut self, other: Self) -> Self {
         self.0 |= other.0;
         *self
     }
@@ -170,13 +170,13 @@ impl ServiceFlags {
     ///
     /// Returns itself.
     #[must_use]
-    pub fn remove(&mut self, other: ServiceFlags) -> ServiceFlags {
+    pub fn remove(&mut self, other: Self) -> Self {
         self.0 &= !other.0;
         *self
     }
 
     /// Checks whether [ServiceFlags] are included in this one.
-    pub fn has(self, flags: ServiceFlags) -> bool { (self.0 | flags.0) == self.0 }
+    pub fn has(self, flags: Self) -> bool { (self.0 | flags.0) == self.0 }
 
     /// Gets the integer representation of this [`ServiceFlags`].
     pub fn to_u64(self) -> u64 { self.0 }
@@ -195,7 +195,7 @@ impl fmt::UpperHex for ServiceFlags {
 impl fmt::Display for ServiceFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut flags = *self;
-        if flags == ServiceFlags::NONE {
+        if flags == Self::NONE {
             return write!(f, "ServiceFlags(NONE)");
         }
         let mut first = true;
@@ -220,7 +220,7 @@ impl fmt::Display for ServiceFlags {
         write_flag!(NETWORK_LIMITED);
         write_flag!(P2P_V2);
         // If there are unknown flags left, we append them in hex.
-        if flags != ServiceFlags::NONE {
+        if flags != Self::NONE {
             if !first {
                 write!(f, "|")?;
             }
@@ -231,7 +231,7 @@ impl fmt::Display for ServiceFlags {
 }
 
 impl From<u64> for ServiceFlags {
-    fn from(f: u64) -> Self { ServiceFlags(f) }
+    fn from(f: u64) -> Self { Self(f) }
 }
 
 impl From<ServiceFlags> for u64 {
@@ -268,7 +268,7 @@ impl Encodable for ServiceFlags {
 impl Decodable for ServiceFlags {
     #[inline]
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(ServiceFlags(Decodable::consensus_decode(r)?))
+        Ok(Self(Decodable::consensus_decode(r)?))
     }
 }
 /// Network magic bytes to identify the cryptocurrency network the message was intended for.
@@ -288,7 +288,7 @@ impl Magic {
     pub const REGTEST: Self = Self([0xFA, 0xBF, 0xB5, 0xDA]);
 
     /// Constructs a new network magic from bytes.
-    pub const fn from_bytes(bytes: [u8; 4]) -> Magic { Magic(bytes) }
+    pub const fn from_bytes(bytes: [u8; 4]) -> Self { Self(bytes) }
 
     /// Gets network magic bytes.
     pub fn to_bytes(self) -> [u8; 4] { self.0 }
@@ -302,9 +302,9 @@ impl Magic {
 impl FromStr for Magic {
     type Err = ParseMagicError;
 
-    fn from_str(s: &str) -> Result<Magic, Self::Err> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         match <[u8; 4]>::from_hex(s) {
-            Ok(magic) => Ok(Magic::from_bytes(magic)),
+            Ok(magic) => Ok(Self::from_bytes(magic)),
             Err(e) => Err(ParseMagicError { error: e, magic: s.to_owned() }),
         }
     }
@@ -315,11 +315,11 @@ impl TryFrom<Network> for Magic {
 
     fn try_from(network: Network) -> Result<Self, Self::Error> {
         match network {
-            Network::Bitcoin => Ok(Magic::BITCOIN),
-            Network::Testnet(TestnetVersion::V3) => Ok(Magic::TESTNET3),
-            Network::Testnet(TestnetVersion::V4) => Ok(Magic::TESTNET4),
-            Network::Signet => Ok(Magic::SIGNET),
-            Network::Regtest => Ok(Magic::REGTEST),
+            Network::Bitcoin => Ok(Self::BITCOIN),
+            Network::Testnet(TestnetVersion::V3) => Ok(Self::TESTNET3),
+            Network::Testnet(TestnetVersion::V4) => Ok(Self::TESTNET4),
+            Network::Signet => Ok(Self::SIGNET),
+            Network::Regtest => Ok(Self::REGTEST),
             _ => Err(UnknownNetworkError(network)),
         }
     }
@@ -330,11 +330,11 @@ impl TryFrom<Magic> for Network {
 
     fn try_from(magic: Magic) -> Result<Self, Self::Error> {
         match magic {
-            Magic::BITCOIN => Ok(Network::Bitcoin),
-            Magic::TESTNET3 => Ok(Network::Testnet(TestnetVersion::V3)),
-            Magic::TESTNET4 => Ok(Network::Testnet(TestnetVersion::V4)),
-            Magic::SIGNET => Ok(Network::Signet),
-            Magic::REGTEST => Ok(Network::Regtest),
+            Magic::BITCOIN => Ok(Self::Bitcoin),
+            Magic::TESTNET3 => Ok(Self::Testnet(TestnetVersion::V3)),
+            Magic::TESTNET4 => Ok(Self::Testnet(TestnetVersion::V4)),
+            Magic::SIGNET => Ok(Self::Signet),
+            Magic::REGTEST => Ok(Self::Regtest),
             _ => Err(UnknownMagicError(magic)),
         }
     }
@@ -374,7 +374,7 @@ impl Encodable for Magic {
 
 impl Decodable for Magic {
     fn consensus_decode<R: BufRead + ?Sized>(reader: &mut R) -> Result<Self, encode::Error> {
-        Ok(Magic(Decodable::consensus_decode(reader)?))
+        Ok(Self(Decodable::consensus_decode(reader)?))
     }
 }
 
@@ -466,20 +466,20 @@ impl std::error::Error for UnknownNetworkError {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for ProtocolVersion {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(ProtocolVersion(u.arbitrary()?))
+        Ok(Self(u.arbitrary()?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for ServiceFlags {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(ServiceFlags(u.arbitrary()?))
+        Ok(Self(u.arbitrary()?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Magic {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Magic(u.arbitrary()?)) }
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
 }
 
 #[cfg(test)]
diff --git a/p2p/src/message.rs b/p2p/src/message.rs
index 777ff5bb..ec93e0a7 100644
--- a/p2p/src/message.rs
+++ b/p2p/src/message.rs
@@ -53,15 +53,15 @@ impl CommandString {
     ///
     /// Returns an error if, and only if, the string is
     /// larger than 12 characters in length.
-    pub fn try_from_static(s: &'static str) -> Result<CommandString, CommandStringError> {
+    pub fn try_from_static(s: &'static str) -> Result<Self, CommandStringError> {
         Self::try_from_static_cow(s.into())
     }
 
-    fn try_from_static_cow(cow: Cow<'static, str>) -> Result<CommandString, CommandStringError> {
+    fn try_from_static_cow(cow: Cow<'static, str>) -> Result<Self, CommandStringError> {
         if cow.len() > 12 {
             Err(CommandStringError { cow })
         } else {
-            Ok(CommandString(cow))
+            Ok(Self(cow))
         }
     }
 }
@@ -129,7 +129,7 @@ impl Decodable for CommandString {
             return Err(crate::consensus::parse_failed_error("Command string must be ASCII"));
         }
 
-        Ok(CommandString(Cow::Owned(unsafe { String::from_utf8_unchecked(trimmed.to_vec()) })))
+        Ok(Self(Cow::Owned(unsafe { String::from_utf8_unchecked(trimmed.to_vec()) })))
     }
 }
 
@@ -297,50 +297,50 @@ impl NetworkMessage {
     /// Use the [Self::command] method to get the command for unknown messages.
     pub fn cmd(&self) -> &'static str {
         match *self {
-            NetworkMessage::Version(_) => "version",
-            NetworkMessage::Verack => "verack",
-            NetworkMessage::Addr(_) => "addr",
-            NetworkMessage::Inv(_) => "inv",
-            NetworkMessage::GetData(_) => "getdata",
-            NetworkMessage::NotFound(_) => "notfound",
-            NetworkMessage::GetBlocks(_) => "getblocks",
-            NetworkMessage::GetHeaders(_) => "getheaders",
-            NetworkMessage::MemPool => "mempool",
-            NetworkMessage::Tx(_) => "tx",
-            NetworkMessage::Block(_) => "block",
-            NetworkMessage::Headers(_) => "headers",
-            NetworkMessage::SendHeaders => "sendheaders",
-            NetworkMessage::GetAddr => "getaddr",
-            NetworkMessage::Ping(_) => "ping",
-            NetworkMessage::Pong(_) => "pong",
-            NetworkMessage::MerkleBlock(_) => "merkleblock",
-            NetworkMessage::FilterLoad(_) => "filterload",
-            NetworkMessage::FilterAdd(_) => "filteradd",
-            NetworkMessage::FilterClear => "filterclear",
-            NetworkMessage::GetCFilters(_) => "getcfilters",
-            NetworkMessage::CFilter(_) => "cfilter",
-            NetworkMessage::GetCFHeaders(_) => "getcfheaders",
-            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",
-            NetworkMessage::WtxidRelay => "wtxidrelay",
-            NetworkMessage::AddrV2(_) => "addrv2",
-            NetworkMessage::SendAddrV2 => "sendaddrv2",
-            NetworkMessage::Unknown { .. } => "unknown",
+            Self::Version(_) => "version",
+            Self::Verack => "verack",
+            Self::Addr(_) => "addr",
+            Self::Inv(_) => "inv",
+            Self::GetData(_) => "getdata",
+            Self::NotFound(_) => "notfound",
+            Self::GetBlocks(_) => "getblocks",
+            Self::GetHeaders(_) => "getheaders",
+            Self::MemPool => "mempool",
+            Self::Tx(_) => "tx",
+            Self::Block(_) => "block",
+            Self::Headers(_) => "headers",
+            Self::SendHeaders => "sendheaders",
+            Self::GetAddr => "getaddr",
+            Self::Ping(_) => "ping",
+            Self::Pong(_) => "pong",
+            Self::MerkleBlock(_) => "merkleblock",
+            Self::FilterLoad(_) => "filterload",
+            Self::FilterAdd(_) => "filteradd",
+            Self::FilterClear => "filterclear",
+            Self::GetCFilters(_) => "getcfilters",
+            Self::CFilter(_) => "cfilter",
+            Self::GetCFHeaders(_) => "getcfheaders",
+            Self::CFHeaders(_) => "cfheaders",
+            Self::GetCFCheckpt(_) => "getcfcheckpt",
+            Self::CFCheckpt(_) => "cfcheckpt",
+            Self::SendCmpct(_) => "sendcmpct",
+            Self::CmpctBlock(_) => "cmpctblock",
+            Self::GetBlockTxn(_) => "getblocktxn",
+            Self::BlockTxn(_) => "blocktxn",
+            Self::Alert(_) => "alert",
+            Self::Reject(_) => "reject",
+            Self::FeeFilter(_) => "feefilter",
+            Self::WtxidRelay => "wtxidrelay",
+            Self::AddrV2(_) => "addrv2",
+            Self::SendAddrV2 => "sendaddrv2",
+            Self::Unknown { .. } => "unknown",
         }
     }
 
     /// Returns the CommandString for the message command.
     pub fn command(&self) -> CommandString {
         match *self {
-            NetworkMessage::Unknown { command: ref c, .. } => c.clone(),
+            Self::Unknown { command: ref c, .. } => c.clone(),
             _ => CommandString::try_from_static(self.cmd()).expect("cmd returns valid commands"),
         }
     }
@@ -415,44 +415,44 @@ impl Encodable for HeadersMessage {
 impl Encodable for NetworkMessage {
     fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
         match self {
-            NetworkMessage::Version(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Addr(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Inv(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetData(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::NotFound(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetBlocks(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetHeaders(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Tx(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Block(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Headers(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Ping(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Pong(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::MerkleBlock(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::FilterLoad(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::FilterAdd(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetCFilters(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CFilter(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetCFHeaders(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CFHeaders(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetCFCheckpt(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CFCheckpt(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::SendCmpct(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CmpctBlock(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetBlockTxn(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::BlockTxn(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Alert(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Reject(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::FeeFilter(ref dat) =>
+            Self::Version(ref dat) => dat.consensus_encode(writer),
+            Self::Addr(ref dat) => dat.consensus_encode(writer),
+            Self::Inv(ref dat) => dat.consensus_encode(writer),
+            Self::GetData(ref dat) => dat.consensus_encode(writer),
+            Self::NotFound(ref dat) => dat.consensus_encode(writer),
+            Self::GetBlocks(ref dat) => dat.consensus_encode(writer),
+            Self::GetHeaders(ref dat) => dat.consensus_encode(writer),
+            Self::Tx(ref dat) => dat.consensus_encode(writer),
+            Self::Block(ref dat) => dat.consensus_encode(writer),
+            Self::Headers(ref dat) => dat.consensus_encode(writer),
+            Self::Ping(ref dat) => dat.consensus_encode(writer),
+            Self::Pong(ref dat) => dat.consensus_encode(writer),
+            Self::MerkleBlock(ref dat) => dat.consensus_encode(writer),
+            Self::FilterLoad(ref dat) => dat.consensus_encode(writer),
+            Self::FilterAdd(ref dat) => dat.consensus_encode(writer),
+            Self::GetCFilters(ref dat) => dat.consensus_encode(writer),
+            Self::CFilter(ref dat) => dat.consensus_encode(writer),
+            Self::GetCFHeaders(ref dat) => dat.consensus_encode(writer),
+            Self::CFHeaders(ref dat) => dat.consensus_encode(writer),
+            Self::GetCFCheckpt(ref dat) => dat.consensus_encode(writer),
+            Self::CFCheckpt(ref dat) => dat.consensus_encode(writer),
+            Self::SendCmpct(ref dat) => dat.consensus_encode(writer),
+            Self::CmpctBlock(ref dat) => dat.consensus_encode(writer),
+            Self::GetBlockTxn(ref dat) => dat.consensus_encode(writer),
+            Self::BlockTxn(ref dat) => dat.consensus_encode(writer),
+            Self::Alert(ref dat) => dat.consensus_encode(writer),
+            Self::Reject(ref dat) => dat.consensus_encode(writer),
+            Self::FeeFilter(ref dat) =>
                 dat.to_sat_per_kvb_ceil().consensus_encode(writer),
-            NetworkMessage::AddrV2(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Verack
-            | NetworkMessage::SendHeaders
-            | NetworkMessage::MemPool
-            | NetworkMessage::GetAddr
-            | NetworkMessage::WtxidRelay
-            | NetworkMessage::FilterClear
-            | NetworkMessage::SendAddrV2 => Ok(0),
-            NetworkMessage::Unknown { payload: ref data, .. } => data.consensus_encode(writer),
+            Self::AddrV2(ref dat) => dat.consensus_encode(writer),
+            Self::Verack
+            | Self::SendHeaders
+            | Self::MemPool
+            | Self::GetAddr
+            | Self::WtxidRelay
+            | Self::FilterClear
+            | Self::SendAddrV2 => Ok(0),
+            Self::Unknown { payload: ref data, .. } => data.consensus_encode(writer),
         }
     }
 }
@@ -565,7 +565,7 @@ impl Decodable for HeadersMessage {
                 ));
             }
         }
-        Ok(HeadersMessage(ret))
+        Ok(Self(ret))
     }
 
     #[inline]
@@ -677,7 +677,7 @@ impl Decodable for RawNetworkMessage {
             "sendaddrv2" => NetworkMessage::SendAddrV2,
             _ => NetworkMessage::Unknown { command: cmd, payload: raw_payload },
         };
-        Ok(RawNetworkMessage { magic, payload, payload_len, checksum })
+        Ok(Self { magic, payload, payload_len, checksum })
     }
 
     #[inline]
@@ -756,7 +756,7 @@ impl Decodable for V2NetworkMessage {
                     "Unknown short ID",
                 ))),
         };
-        Ok(V2NetworkMessage { payload })
+        Ok(Self { payload })
     }
 
     #[inline]
@@ -818,7 +818,7 @@ impl Decodable for CheckedData {
             }
             .into())
         } else {
-            Ok(CheckedData { data, checksum })
+            Ok(Self { data, checksum })
         }
     }
 }
@@ -863,35 +863,35 @@ fn sha2_checksum(data: &[u8]) -> [u8; 4] {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for AddrPayload {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(AddrPayload(Vec::<(u32, Address)>::arbitrary(u)?))
+        Ok(Self(Vec::<(u32, Address)>::arbitrary(u)?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for AddrV2Payload {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(AddrV2Payload(Vec::<AddrV2Message>::arbitrary(u)?))
+        Ok(Self(Vec::<AddrV2Message>::arbitrary(u)?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for InventoryPayload {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(InventoryPayload(Vec::<message_blockdata::Inventory>::arbitrary(u)?))
+        Ok(Self(Vec::<message_blockdata::Inventory>::arbitrary(u)?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for CommandString {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(CommandString(u.arbitrary::<String>()?.into()))
+        Ok(Self(u.arbitrary::<String>()?.into()))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for HeadersMessage {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(HeadersMessage(u.arbitrary()?))
+        Ok(Self(u.arbitrary()?))
     }
 }
 
@@ -899,43 +899,43 @@ impl<'a> Arbitrary<'a> for HeadersMessage {
 impl<'a> Arbitrary<'a> for NetworkMessage {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         match u.int_in_range(0..=36)? {
-            0 => Ok(NetworkMessage::Version(u.arbitrary()?)),
-            1 => Ok(NetworkMessage::Verack),
-            2 => Ok(NetworkMessage::Addr(u.arbitrary()?)),
-            3 => Ok(NetworkMessage::Inv(u.arbitrary()?)),
-            4 => Ok(NetworkMessage::GetData(u.arbitrary()?)),
-            5 => Ok(NetworkMessage::NotFound(u.arbitrary()?)),
-            6 => Ok(NetworkMessage::GetBlocks(u.arbitrary()?)),
-            7 => Ok(NetworkMessage::GetHeaders(u.arbitrary()?)),
-            8 => Ok(NetworkMessage::MemPool),
-            9 => Ok(NetworkMessage::Tx(u.arbitrary()?)),
-            10 => Ok(NetworkMessage::Block(u.arbitrary()?)),
-            11 => Ok(NetworkMessage::Headers(u.arbitrary()?)),
-            12 => Ok(NetworkMessage::SendHeaders),
-            13 => Ok(NetworkMessage::GetAddr),
-            14 => Ok(NetworkMessage::Ping(u.arbitrary()?)),
-            15 => Ok(NetworkMessage::Pong(u.arbitrary()?)),
-            16 => Ok(NetworkMessage::MerkleBlock(u.arbitrary()?)),
-            17 => Ok(NetworkMessage::FilterLoad(u.arbitrary()?)),
-            18 => Ok(NetworkMessage::FilterAdd(u.arbitrary()?)),
-            19 => Ok(NetworkMessage::FilterClear),
-            20 => Ok(NetworkMessage::GetCFilters(u.arbitrary()?)),
-            21 => Ok(NetworkMessage::CFilter(u.arbitrary()?)),
-            22 => Ok(NetworkMessage::GetCFHeaders(u.arbitrary()?)),
-            23 => Ok(NetworkMessage::CFHeaders(u.arbitrary()?)),
-            24 => Ok(NetworkMessage::GetCFCheckpt(u.arbitrary()?)),
-            25 => Ok(NetworkMessage::CFCheckpt(u.arbitrary()?)),
-            26 => Ok(NetworkMessage::SendCmpct(u.arbitrary()?)),
-            27 => Ok(NetworkMessage::CmpctBlock(u.arbitrary()?)),
-            28 => Ok(NetworkMessage::GetBlockTxn(u.arbitrary()?)),
-            29 => Ok(NetworkMessage::BlockTxn(u.arbitrary()?)),
-            30 => Ok(NetworkMessage::Alert(u.arbitrary()?)),
-            31 => Ok(NetworkMessage::Reject(u.arbitrary()?)),
-            32 => Ok(NetworkMessage::FeeFilter(u.arbitrary()?)),
-            33 => Ok(NetworkMessage::WtxidRelay),
-            34 => Ok(NetworkMessage::AddrV2(u.arbitrary()?)),
-            35 => Ok(NetworkMessage::SendAddrV2),
-            _ => Ok(NetworkMessage::Unknown {
+            0 => Ok(Self::Version(u.arbitrary()?)),
+            1 => Ok(Self::Verack),
+            2 => Ok(Self::Addr(u.arbitrary()?)),
+            3 => Ok(Self::Inv(u.arbitrary()?)),
+            4 => Ok(Self::GetData(u.arbitrary()?)),
+            5 => Ok(Self::NotFound(u.arbitrary()?)),
+            6 => Ok(Self::GetBlocks(u.arbitrary()?)),
+            7 => Ok(Self::GetHeaders(u.arbitrary()?)),
+            8 => Ok(Self::MemPool),
+            9 => Ok(Self::Tx(u.arbitrary()?)),
+            10 => Ok(Self::Block(u.arbitrary()?)),
+            11 => Ok(Self::Headers(u.arbitrary()?)),
+            12 => Ok(Self::SendHeaders),
+            13 => Ok(Self::GetAddr),
+            14 => Ok(Self::Ping(u.arbitrary()?)),
+            15 => Ok(Self::Pong(u.arbitrary()?)),
+            16 => Ok(Self::MerkleBlock(u.arbitrary()?)),
+            17 => Ok(Self::FilterLoad(u.arbitrary()?)),
+            18 => Ok(Self::FilterAdd(u.arbitrary()?)),
+            19 => Ok(Self::FilterClear),
+            20 => Ok(Self::GetCFilters(u.arbitrary()?)),
+            21 => Ok(Self::CFilter(u.arbitrary()?)),
+            22 => Ok(Self::GetCFHeaders(u.arbitrary()?)),
+            23 => Ok(Self::CFHeaders(u.arbitrary()?)),
+            24 => Ok(Self::GetCFCheckpt(u.arbitrary()?)),
+            25 => Ok(Self::CFCheckpt(u.arbitrary()?)),
+            26 => Ok(Self::SendCmpct(u.arbitrary()?)),
+            27 => Ok(Self::CmpctBlock(u.arbitrary()?)),
+            28 => Ok(Self::GetBlockTxn(u.arbitrary()?)),
+            29 => Ok(Self::BlockTxn(u.arbitrary()?)),
+            30 => Ok(Self::Alert(u.arbitrary()?)),
+            31 => Ok(Self::Reject(u.arbitrary()?)),
+            32 => Ok(Self::FeeFilter(u.arbitrary()?)),
+            33 => Ok(Self::WtxidRelay),
+            34 => Ok(Self::AddrV2(u.arbitrary()?)),
+            35 => Ok(Self::SendAddrV2),
+            _ => Ok(Self::Unknown {
                 command: u.arbitrary()?,
                 payload: Vec::<u8>::arbitrary(u)?,
             }),
@@ -946,7 +946,7 @@ impl<'a> Arbitrary<'a> for NetworkMessage {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for RawNetworkMessage {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(RawNetworkMessage::new(u.arbitrary()?, u.arbitrary()?))
+        Ok(Self::new(u.arbitrary()?, u.arbitrary()?))
     }
 }
 
diff --git a/p2p/src/message_blockdata.rs b/p2p/src/message_blockdata.rs
index 72ef0fbd..788e4c00 100644
--- a/p2p/src/message_blockdata.rs
+++ b/p2p/src/message_blockdata.rs
@@ -50,14 +50,14 @@ impl Inventory {
     /// Returns [None] only for [Inventory::Error] who's hash value is meaningless.
     pub fn network_hash(&self) -> Option<[u8; 32]> {
         match self {
-            Inventory::Error(_) => None,
-            Inventory::Transaction(t) => Some(t.to_byte_array()),
-            Inventory::Block(b) => Some(b.to_byte_array()),
-            Inventory::CompactBlock(b) => Some(b.to_byte_array()),
-            Inventory::WTx(t) => Some(t.to_byte_array()),
-            Inventory::WitnessTransaction(t) => Some(t.to_byte_array()),
-            Inventory::WitnessBlock(b) => Some(b.to_byte_array()),
-            Inventory::Unknown { hash, .. } => Some(*hash),
+            Self::Error(_) => None,
+            Self::Transaction(t) => Some(t.to_byte_array()),
+            Self::Block(b) => Some(b.to_byte_array()),
+            Self::CompactBlock(b) => Some(b.to_byte_array()),
+            Self::WTx(t) => Some(t.to_byte_array()),
+            Self::WitnessTransaction(t) => Some(t.to_byte_array()),
+            Self::WitnessBlock(b) => Some(b.to_byte_array()),
+            Self::Unknown { hash, .. } => Some(*hash),
         }
     }
 }
@@ -71,14 +71,14 @@ impl Encodable for Inventory {
             };
         }
         Ok(match *self {
-            Inventory::Error(ref e) => encode_inv!(0, e),
-            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(ref w) => encode_inv!(5, w),
-            Inventory::WitnessTransaction(ref t) => encode_inv!(0x40000001, t),
-            Inventory::WitnessBlock(ref b) => encode_inv!(0x40000002, b),
-            Inventory::Unknown { inv_type: t, hash: ref d } => encode_inv!(t, d),
+            Self::Error(ref e) => encode_inv!(0, e),
+            Self::Transaction(ref t) => encode_inv!(1, t),
+            Self::Block(ref b) => encode_inv!(2, b),
+            Self::CompactBlock(ref b) => encode_inv!(4, b),
+            Self::WTx(ref w) => encode_inv!(5, w),
+            Self::WitnessTransaction(ref t) => encode_inv!(0x40000001, t),
+            Self::WitnessBlock(ref b) => encode_inv!(0x40000002, b),
+            Self::Unknown { inv_type: t, hash: ref d } => encode_inv!(t, d),
         })
     }
 }
@@ -88,14 +88,14 @@ impl Decodable for Inventory {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         let inv_type: u32 = Decodable::consensus_decode(r)?;
         Ok(match inv_type {
-            0 => Inventory::Error(Decodable::consensus_decode(r)?),
-            1 => Inventory::Transaction(Decodable::consensus_decode(r)?),
-            2 => Inventory::Block(Decodable::consensus_decode(r)?),
-            4 => Inventory::CompactBlock(Decodable::consensus_decode(r)?),
-            5 => Inventory::WTx(Decodable::consensus_decode(r)?),
-            0x40000001 => Inventory::WitnessTransaction(Decodable::consensus_decode(r)?),
-            0x40000002 => Inventory::WitnessBlock(Decodable::consensus_decode(r)?),
-            tp => Inventory::Unknown { inv_type: tp, hash: Decodable::consensus_decode(r)? },
+            0 => Self::Error(Decodable::consensus_decode(r)?),
+            1 => Self::Transaction(Decodable::consensus_decode(r)?),
+            2 => Self::Block(Decodable::consensus_decode(r)?),
+            4 => Self::CompactBlock(Decodable::consensus_decode(r)?),
+            5 => Self::WTx(Decodable::consensus_decode(r)?),
+            0x40000001 => Self::WitnessTransaction(Decodable::consensus_decode(r)?),
+            0x40000002 => Self::WitnessBlock(Decodable::consensus_decode(r)?),
+            tp => Self::Unknown { inv_type: tp, hash: Decodable::consensus_decode(r)? },
         })
     }
 }
@@ -135,7 +135,7 @@ impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash);
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for GetHeadersMessage {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(GetHeadersMessage {
+        Ok(Self {
             version: u.arbitrary()?,
             locator_hashes: Vec::<BlockHash>::arbitrary(u)?,
             stop_hash: u.arbitrary()?,
@@ -146,7 +146,7 @@ impl<'a> Arbitrary<'a> for GetHeadersMessage {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for GetBlocksMessage {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(GetBlocksMessage {
+        Ok(Self {
             version: u.arbitrary()?,
             locator_hashes: Vec::<BlockHash>::arbitrary(u)?,
             stop_hash: u.arbitrary()?,
@@ -158,14 +158,14 @@ impl<'a> Arbitrary<'a> for GetBlocksMessage {
 impl<'a> Arbitrary<'a> for Inventory {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         match u.int_in_range(0..=7)? {
-            0 => Ok(Inventory::Error(u.arbitrary()?)),
-            1 => Ok(Inventory::Transaction(u.arbitrary()?)),
-            2 => Ok(Inventory::Block(u.arbitrary()?)),
-            3 => Ok(Inventory::CompactBlock(u.arbitrary()?)),
-            4 => Ok(Inventory::WTx(u.arbitrary()?)),
-            5 => Ok(Inventory::WitnessTransaction(u.arbitrary()?)),
-            6 => Ok(Inventory::WitnessBlock(u.arbitrary()?)),
-            _ => Ok(Inventory::Unknown { inv_type: u.arbitrary()?, hash: u.arbitrary()? }),
+            0 => Ok(Self::Error(u.arbitrary()?)),
+            1 => Ok(Self::Transaction(u.arbitrary()?)),
+            2 => Ok(Self::Block(u.arbitrary()?)),
+            3 => Ok(Self::CompactBlock(u.arbitrary()?)),
+            4 => Ok(Self::WTx(u.arbitrary()?)),
+            5 => Ok(Self::WitnessTransaction(u.arbitrary()?)),
+            6 => Ok(Self::WitnessBlock(u.arbitrary()?)),
+            _ => Ok(Self::Unknown { inv_type: u.arbitrary()?, hash: u.arbitrary()? }),
         }
     }
 }
diff --git a/p2p/src/message_bloom.rs b/p2p/src/message_bloom.rs
index 4722949c..c09ddce1 100644
--- a/p2p/src/message_bloom.rs
+++ b/p2p/src/message_bloom.rs
@@ -42,9 +42,9 @@ pub enum BloomFlags {
 impl Encodable for BloomFlags {
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
         w.write_all(&[match self {
-            BloomFlags::None => 0,
-            BloomFlags::All => 1,
-            BloomFlags::PubkeyOnly => 2,
+            Self::None => 0,
+            Self::All => 1,
+            Self::PubkeyOnly => 2,
         }])?;
         Ok(1)
     }
@@ -53,9 +53,9 @@ impl Encodable for BloomFlags {
 impl Decodable for BloomFlags {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         Ok(match r.read_u8()? {
-            0 => BloomFlags::None,
-            1 => BloomFlags::All,
-            2 => BloomFlags::PubkeyOnly,
+            0 => Self::None,
+            1 => Self::All,
+            2 => Self::PubkeyOnly,
             _ => return Err(crate::consensus::parse_failed_error("unknown bloom flag")),
         })
     }
@@ -74,9 +74,9 @@ impl_consensus_encoding!(FilterAdd, data);
 impl<'a> Arbitrary<'a> for BloomFlags {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         match u.int_in_range(0..=2)? {
-            0 => Ok(BloomFlags::None),
-            1 => Ok(BloomFlags::All),
-            _ => Ok(BloomFlags::PubkeyOnly),
+            0 => Ok(Self::None),
+            1 => Ok(Self::All),
+            _ => Ok(Self::PubkeyOnly),
         }
     }
 }
@@ -84,14 +84,14 @@ impl<'a> Arbitrary<'a> for BloomFlags {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for FilterAdd {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(FilterAdd { data: Vec::<u8>::arbitrary(u)? })
+        Ok(Self { data: Vec::<u8>::arbitrary(u)? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for FilterLoad {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(FilterLoad {
+        Ok(Self {
             filter: Vec::<u8>::arbitrary(u)?,
             hash_funcs: u.arbitrary()?,
             tweak: u.arbitrary()?,
diff --git a/p2p/src/message_compact_blocks.rs b/p2p/src/message_compact_blocks.rs
index af8f141e..37a495d1 100644
--- a/p2p/src/message_compact_blocks.rs
+++ b/p2p/src/message_compact_blocks.rs
@@ -51,27 +51,27 @@ impl_consensus_encoding!(BlockTxn, transactions);
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for SendCmpct {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(SendCmpct { send_compact: u.arbitrary()?, version: u.arbitrary()? })
+        Ok(Self { send_compact: u.arbitrary()?, version: u.arbitrary()? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for CmpctBlock {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(CmpctBlock { compact_block: u.arbitrary()? })
+        Ok(Self { compact_block: u.arbitrary()? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for GetBlockTxn {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(GetBlockTxn { txs_request: u.arbitrary()? })
+        Ok(Self { txs_request: u.arbitrary()? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for BlockTxn {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(BlockTxn { transactions: u.arbitrary()? })
+        Ok(Self { transactions: u.arbitrary()? })
     }
 }
diff --git a/p2p/src/message_filter.rs b/p2p/src/message_filter.rs
index 434df752..a8a5a6b7 100644
--- a/p2p/src/message_filter.rs
+++ b/p2p/src/message_filter.rs
@@ -89,7 +89,7 @@ impl_consensus_encoding!(CFCheckpt, filter_type, stop_hash, filter_headers);
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for GetCFilters {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(GetCFilters {
+        Ok(Self {
             filter_type: u.arbitrary()?,
             start_height: u.arbitrary()?,
             stop_hash: u.arbitrary()?,
@@ -100,7 +100,7 @@ impl<'a> Arbitrary<'a> for GetCFilters {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for CFilter {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(CFilter {
+        Ok(Self {
             filter_type: u.arbitrary()?,
             block_hash: u.arbitrary()?,
             filter: Vec::<u8>::arbitrary(u)?,
@@ -111,7 +111,7 @@ impl<'a> Arbitrary<'a> for CFilter {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for GetCFHeaders {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(GetCFHeaders {
+        Ok(Self {
             filter_type: u.arbitrary()?,
             start_height: u.arbitrary()?,
             stop_hash: u.arbitrary()?,
@@ -122,7 +122,7 @@ impl<'a> Arbitrary<'a> for GetCFHeaders {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for CFHeaders {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(CFHeaders {
+        Ok(Self {
             filter_type: u.arbitrary()?,
             stop_hash: u.arbitrary()?,
             previous_filter_header: u.arbitrary()?,
@@ -134,14 +134,14 @@ impl<'a> Arbitrary<'a> for CFHeaders {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for GetCFCheckpt {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(GetCFCheckpt { filter_type: u.arbitrary()?, stop_hash: u.arbitrary()? })
+        Ok(Self { filter_type: u.arbitrary()?, stop_hash: u.arbitrary()? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for CFCheckpt {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(CFCheckpt {
+        Ok(Self {
             filter_type: u.arbitrary()?,
             stop_hash: u.arbitrary()?,
             filter_headers: Vec::<FilterHeader>::arbitrary(u)?,
diff --git a/p2p/src/message_network.rs b/p2p/src/message_network.rs
index 5b22c6b0..b5fa1154 100644
--- a/p2p/src/message_network.rs
+++ b/p2p/src/message_network.rs
@@ -65,8 +65,8 @@ impl VersionMessage {
         nonce: u64,
         user_agent: UserAgent,
         start_height: i32,
-    ) -> VersionMessage {
-        VersionMessage {
+    ) -> Self {
+        Self {
             version,
             services,
             timestamp,
@@ -277,14 +277,14 @@ impl Encodable for RejectReason {
 impl Decodable for RejectReason {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         Ok(match r.read_u8()? {
-            0x01 => RejectReason::Malformed,
-            0x10 => RejectReason::Invalid,
-            0x11 => RejectReason::Obsolete,
-            0x12 => RejectReason::Duplicate,
-            0x40 => RejectReason::NonStandard,
-            0x41 => RejectReason::Dust,
-            0x42 => RejectReason::Fee,
-            0x43 => RejectReason::Checkpoint,
+            0x01 => Self::Malformed,
+            0x10 => Self::Invalid,
+            0x11 => Self::Obsolete,
+            0x12 => Self::Duplicate,
+            0x40 => Self::NonStandard,
+            0x41 => Self::Dust,
+            0x42 => Self::Fee,
+            0x43 => Self::Checkpoint,
             _ => return Err(crate::consensus::parse_failed_error("unknown reject code")),
         })
     }
@@ -334,12 +334,12 @@ impl_vec_wrapper!(Alert, Vec<u8>);
 impl<'a> Arbitrary<'a> for ClientSoftwareVersion {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         match bool::arbitrary(u)? {
-            true => Ok(ClientSoftwareVersion::Date {
+            true => Ok(Self::Date {
                 yyyy: u.arbitrary()?,
                 mm: u.arbitrary()?,
                 dd: u.arbitrary()?,
             }),
-            false => Ok(ClientSoftwareVersion::SemVer {
+            false => Ok(Self::SemVer {
                 major: u.arbitrary()?,
                 minor: u.arbitrary()?,
                 revision: u.arbitrary()?,
@@ -351,21 +351,21 @@ impl<'a> Arbitrary<'a> for ClientSoftwareVersion {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for UserAgentVersion {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(UserAgentVersion::new(u.arbitrary()?))
+        Ok(Self::new(u.arbitrary()?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for UserAgent {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(UserAgent::new(u.arbitrary::<String>()?, u.arbitrary()?))
+        Ok(Self::new(u.arbitrary::<String>()?, u.arbitrary()?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for VersionMessage {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(VersionMessage::new(
+        Ok(Self::new(
             u.arbitrary()?,
             u.arbitrary()?,
             u.arbitrary()?,
@@ -382,14 +382,14 @@ impl<'a> Arbitrary<'a> for VersionMessage {
 impl<'a> Arbitrary<'a> for RejectReason {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         match u.int_in_range(0..=7)? {
-            0 => Ok(RejectReason::Malformed),
-            1 => Ok(RejectReason::Invalid),
-            2 => Ok(RejectReason::Obsolete),
-            3 => Ok(RejectReason::Duplicate),
-            4 => Ok(RejectReason::NonStandard),
-            5 => Ok(RejectReason::Dust),
-            6 => Ok(RejectReason::Fee),
-            _ => Ok(RejectReason::Checkpoint),
+            0 => Ok(Self::Malformed),
+            1 => Ok(Self::Invalid),
+            2 => Ok(Self::Obsolete),
+            3 => Ok(Self::Duplicate),
+            4 => Ok(Self::NonStandard),
+            5 => Ok(Self::Dust),
+            6 => Ok(Self::Fee),
+            _ => Ok(Self::Checkpoint),
         }
     }
 }
@@ -397,7 +397,7 @@ impl<'a> Arbitrary<'a> for RejectReason {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Reject {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(Reject {
+        Ok(Self {
             message: u.arbitrary::<String>()?.into(),
             ccode: u.arbitrary()?,
             reason: u.arbitrary::<String>()?.into(),
@@ -409,7 +409,7 @@ impl<'a> Arbitrary<'a> for Reject {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Alert {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(Alert(Vec::<u8>::arbitrary(u)?))
+        Ok(Self(Vec::<u8>::arbitrary(u)?))
     }
 }
 
diff --git a/p2p/src/network_ext.rs b/p2p/src/network_ext.rs
index 713306cd..b30e90bb 100644
--- a/p2p/src/network_ext.rs
+++ b/p2p/src/network_ext.rs
@@ -24,12 +24,12 @@ impl NetworkExt for Network {
     /// This function will be updated as new test networks are defined.
     fn default_p2p_port(self) -> u16 {
         match &self {
-            Network::Bitcoin => 8333,
-            Network::Signet => 38333,
-            Network::Testnet(TestnetVersion::V3) => 18333,
-            Network::Testnet(TestnetVersion::V4) => 48333,
-            Network::Testnet(_) => 48333,
-            Network::Regtest => 18444,
+            Self::Bitcoin => 8333,
+            Self::Signet => 38333,
+            Self::Testnet(TestnetVersion::V3) => 18333,
+            Self::Testnet(TestnetVersion::V4) => 48333,
+            Self::Testnet(_) => 48333,
+            Self::Regtest => 18444,
         }
     }
 
@@ -39,12 +39,12 @@ impl NetworkExt for Network {
     /// This function will be updated as new test networks are defined.
     fn default_network_magic(self) -> Magic {
         match &self {
-            Network::Bitcoin => Magic::BITCOIN,
-            Network::Signet => Magic::SIGNET,
-            Network::Testnet(TestnetVersion::V3) => Magic::TESTNET3,
-            Network::Testnet(TestnetVersion::V4) => Magic::TESTNET4,
-            Network::Testnet(_) => Magic::TESTNET4,
-            Network::Regtest => Magic::REGTEST,
+            Self::Bitcoin => Magic::BITCOIN,
+            Self::Signet => Magic::SIGNET,
+            Self::Testnet(TestnetVersion::V3) => Magic::TESTNET3,
+            Self::Testnet(TestnetVersion::V4) => Magic::TESTNET4,
+            Self::Testnet(_) => Magic::TESTNET4,
+            Self::Regtest => Magic::REGTEST,
         }
     }
 }