SyntheticBird/cuprate-hinto-janai
1
0
Fork 0
mirror of https://github.com/hinto-janai/cuprate.git synced 2024-11-16 15:58:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

wire: enable workspace lints

Browse source
This commit is contained in:
hinto.janai 2024-09-18 16:08:21 -04:00
parent 90027143f0
commit 13ac72834a
No known key found for this signature in database
GPG key ID: D47CE05FA175A499
7 changed files with 133 additions and 135 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
net/wire/Cargo.toml
View file

@ -15,7 +15,7 @@ cuprate-levin = { path = "../levin" }
cuprate-epee-encoding = { path = "../epee-encoding" }
cuprate-fixed-bytes = { path = "../fixed-bytes" }
cuprate-types = { path = "../../types", default-features = false, features = ["epee"] }
cuprate-helper = { path = "../../helper", default-features = false, features = ["cast"] }
cuprate-helper = { path = "../../helper", default-features = false, features = ["map"] }
bitflags = { workspace = true, features = ["std"] }
bytes = { workspace = true, features = ["std"] }
@ -24,3 +24,5 @@ thiserror = { workspace = true }
[dev-dependencies]
hex = { workspace = true, features = ["std"]}
[lints]
workspace = true

16
net/wire/src/network_address.rs
View file

@ -51,38 +51,38 @@ impl EpeeObject for NetworkAddress {
}
impl NetworkAddress {
pub fn get_zone(&self) -> NetZone {
pub const fn get_zone(&self) -> NetZone {
match self {
NetworkAddress::Clear(_) => NetZone::Public,
Self::Clear(_) => NetZone::Public,
}
}
pub fn is_loopback(&self) -> bool {
pub const fn is_loopback(&self) -> bool {
// TODO
false
}
pub fn is_local(&self) -> bool {
pub const fn is_local(&self) -> bool {
// TODO
false
}
pub fn port(&self) -> u16 {
pub const fn port(&self) -> u16 {
match self {
NetworkAddress::Clear(ip) => ip.port(),
Self::Clear(ip) => ip.port(),
}
}
}
impl From<net::SocketAddrV4> for NetworkAddress {
fn from(value: net::SocketAddrV4) -> Self {
NetworkAddress::Clear(value.into())
Self::Clear(value.into())
}
}
impl From<net::SocketAddrV6> for NetworkAddress {
fn from(value: net::SocketAddrV6) -> Self {
NetworkAddress::Clear(value.into())
Self::Clear(value.into())
}
}

4
net/wire/src/network_address/epee_builder.rs
View file

@ -74,7 +74,7 @@ impl From<NetworkAddress> for TaggedNetworkAddress {
fn from(value: NetworkAddress) -> Self {
match value {
NetworkAddress::Clear(addr) => match addr {
SocketAddr::V4(addr) => TaggedNetworkAddress {
SocketAddr::V4(addr) => Self {
ty: Some(1),
addr: Some(AllFieldsNetworkAddress {
m_ip: Some(u32::from_be_bytes(addr.ip().octets())),
@ -82,7 +82,7 @@ impl From<NetworkAddress> for TaggedNetworkAddress {
addr: None,
}),
},
SocketAddr::V6(addr) => TaggedNetworkAddress {
SocketAddr::V6(addr) => Self {
ty: Some(2),
addr: Some(AllFieldsNetworkAddress {
addr: Some(addr.ip().octets()),

214
net/wire/src/p2p.rs
View file

@ -55,27 +55,27 @@ pub enum LevinCommand {
impl std::fmt::Display for LevinCommand {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if let LevinCommand::Unknown(id) = self {
return f.write_str(&format!("unknown id: {}", id));
if let Self::Unknown(id) = self {
return f.write_str(&format!("unknown id: {id}"));
}
f.write_str(match self {
LevinCommand::Handshake => "handshake",
LevinCommand::TimedSync => "timed sync",
LevinCommand::Ping => "ping",
LevinCommand::SupportFlags => "support flags",
Self::Handshake => "handshake",
Self::TimedSync => "timed sync",
Self::Ping => "ping",
Self::SupportFlags => "support flags",
LevinCommand::NewBlock => "new block",
LevinCommand::NewTransactions => "new transactions",
LevinCommand::GetObjectsRequest => "get objects request",
LevinCommand::GetObjectsResponse => "get objects response",
LevinCommand::ChainRequest => "chain request",
LevinCommand::ChainResponse => "chain response",
LevinCommand::NewFluffyBlock => "new fluffy block",
LevinCommand::FluffyMissingTxsRequest => "fluffy missing transaction request",
LevinCommand::GetTxPoolCompliment => "get transaction pool compliment",
Self::NewBlock => "new block",
Self::NewTransactions => "new transactions",
Self::GetObjectsRequest => "get objects request",
Self::GetObjectsResponse => "get objects response",
Self::ChainRequest => "chain request",
Self::ChainResponse => "chain response",
Self::NewFluffyBlock => "new fluffy block",
Self::FluffyMissingTxsRequest => "fluffy missing transaction request",
Self::GetTxPoolCompliment => "get transaction pool compliment",
LevinCommand::Unknown(_) => unreachable!(),
Self::Unknown(_) => unreachable!(),
})
}
}
@ -84,49 +84,45 @@ impl LevinCommandTrait for LevinCommand {
fn bucket_size_limit(&self) -> u64 {
// https://github.com/monero-project/monero/blob/00fd416a99686f0956361d1cd0337fe56e58d4a7/src/cryptonote_basic/connection_context.cpp#L37
match self {
LevinCommand::Handshake => 65536,
LevinCommand::TimedSync => 65536,
LevinCommand::Ping => 4096,
LevinCommand::SupportFlags => 4096,
Self::Handshake | Self::TimedSync => 65536,
Self::Ping | Self::SupportFlags => 4096,
LevinCommand::NewBlock => 1024 * 1024 * 128, // 128 MB (max packet is a bit less than 100 MB though)
LevinCommand::NewTransactions => 1024 * 1024 * 128, // 128 MB (max packet is a bit less than 100 MB though)
LevinCommand::GetObjectsRequest => 1024 * 1024 * 2, // 2 MB
LevinCommand::GetObjectsResponse => 1024 * 1024 * 128, // 128 MB (max packet is a bit less than 100 MB though)
LevinCommand::ChainRequest => 512 * 1024, // 512 kB
LevinCommand::ChainResponse => 1024 * 1024 * 4, // 4 MB
LevinCommand::NewFluffyBlock => 1024 * 1024 * 4, // 4 MB
LevinCommand::FluffyMissingTxsRequest => 1024 * 1024, // 1 MB
LevinCommand::GetTxPoolCompliment => 1024 * 1024 * 4, // 4 MB
Self::NewBlock | Self::NewTransactions | Self::GetObjectsResponse => 1024 * 1024 * 128, // 128 MB (max packet is a bit less than 100 MB though)
Self::GetObjectsRequest => 1024 * 1024 * 2, // 2 MB
Self::ChainRequest => 512 * 1024, // 512 kB
Self::ChainResponse | Self::NewFluffyBlock | Self::GetTxPoolCompliment => {
1024 * 1024 * 4
} // 4 MB
Self::FluffyMissingTxsRequest => 1024 * 1024, // 1 MB
LevinCommand::Unknown(_) => u64::MAX,
Self::Unknown(_) => u64::MAX,
}
}
fn is_handshake(&self) -> bool {
matches!(self, LevinCommand::Handshake)
matches!(self, Self::Handshake)
}
}
impl From<u32> for LevinCommand {
fn from(value: u32) -> Self {
match value {
1001 => LevinCommand::Handshake,
1002 => LevinCommand::TimedSync,
1003 => LevinCommand::Ping,
1007 => LevinCommand::SupportFlags,
1001 => Self::Handshake,
1002 => Self::TimedSync,
1003 => Self::Ping,
1007 => Self::SupportFlags,
2001 => LevinCommand::NewBlock,
2002 => LevinCommand::NewTransactions,
2003 => LevinCommand::GetObjectsRequest,
2004 => LevinCommand::GetObjectsResponse,
2006 => LevinCommand::ChainRequest,
2007 => LevinCommand::ChainResponse,
2008 => LevinCommand::NewFluffyBlock,
2009 => LevinCommand::FluffyMissingTxsRequest,
2010 => LevinCommand::GetTxPoolCompliment,
2001 => Self::NewBlock,
2002 => Self::NewTransactions,
2003 => Self::GetObjectsRequest,
2004 => Self::GetObjectsResponse,
2006 => Self::ChainRequest,
2007 => Self::ChainResponse,
2008 => Self::NewFluffyBlock,
2009 => Self::FluffyMissingTxsRequest,
2010 => Self::GetTxPoolCompliment,
x => LevinCommand::Unknown(x),
x => Self::Unknown(x),
}
}
}
@ -191,19 +187,19 @@ pub enum ProtocolMessage {
}
impl ProtocolMessage {
pub fn command(&self) -> LevinCommand {
pub const fn command(&self) -> LevinCommand {
use LevinCommand as C;
match self {
ProtocolMessage::NewBlock(_) => C::NewBlock,
ProtocolMessage::NewFluffyBlock(_) => C::NewFluffyBlock,
ProtocolMessage::GetObjectsRequest(_) => C::GetObjectsRequest,
ProtocolMessage::GetObjectsResponse(_) => C::GetObjectsResponse,
ProtocolMessage::ChainRequest(_) => C::ChainRequest,
ProtocolMessage::ChainEntryResponse(_) => C::ChainResponse,
ProtocolMessage::NewTransactions(_) => C::NewTransactions,
ProtocolMessage::FluffyMissingTransactionsRequest(_) => C::FluffyMissingTxsRequest,
ProtocolMessage::GetTxPoolCompliment(_) => C::GetTxPoolCompliment,
Self::NewBlock(_) => C::NewBlock,
Self::NewFluffyBlock(_) => C::NewFluffyBlock,
Self::GetObjectsRequest(_) => C::GetObjectsRequest,
Self::GetObjectsResponse(_) => C::GetObjectsResponse,
Self::ChainRequest(_) => C::ChainRequest,
Self::ChainEntryResponse(_) => C::ChainResponse,
Self::NewTransactions(_) => C::NewTransactions,
Self::FluffyMissingTransactionsRequest(_) => C::FluffyMissingTxsRequest,
Self::GetTxPoolCompliment(_) => C::GetTxPoolCompliment,
}
}
@ -230,26 +226,26 @@ impl ProtocolMessage {
use LevinCommand as C;
match self {
ProtocolMessage::NewBlock(val) => build_message(C::NewBlock, val, builder)?,
ProtocolMessage::NewTransactions(val) => {
build_message(C::NewTransactions, val, builder)?
Self::NewBlock(val) => build_message(C::NewBlock, val, builder)?,
Self::NewTransactions(val) => {
build_message(C::NewTransactions, val, builder)?;
}
ProtocolMessage::GetObjectsRequest(val) => {
build_message(C::GetObjectsRequest, val, builder)?
Self::GetObjectsRequest(val) => {
build_message(C::GetObjectsRequest, val, builder)?;
}
ProtocolMessage::GetObjectsResponse(val) => {
build_message(C::GetObjectsResponse, val, builder)?
Self::GetObjectsResponse(val) => {
build_message(C::GetObjectsResponse, val, builder)?;
}
ProtocolMessage::ChainRequest(val) => build_message(C::ChainRequest, val, builder)?,
ProtocolMessage::ChainEntryResponse(val) => {
build_message(C::ChainResponse, val, builder)?
Self::ChainRequest(val) => build_message(C::ChainRequest, val, builder)?,
Self::ChainEntryResponse(val) => {
build_message(C::ChainResponse, val, builder)?;
}
ProtocolMessage::NewFluffyBlock(val) => build_message(C::NewFluffyBlock, val, builder)?,
ProtocolMessage::FluffyMissingTransactionsRequest(val) => {
build_message(C::FluffyMissingTxsRequest, val, builder)?
Self::NewFluffyBlock(val) => build_message(C::NewFluffyBlock, val, builder)?,
Self::FluffyMissingTransactionsRequest(val) => {
build_message(C::FluffyMissingTxsRequest, val, builder)?;
}
ProtocolMessage::GetTxPoolCompliment(val) => {
build_message(C::GetTxPoolCompliment, val, builder)?
Self::GetTxPoolCompliment(val) => {
build_message(C::GetTxPoolCompliment, val, builder)?;
}
}
Ok(())
@ -265,14 +261,14 @@ pub enum AdminRequestMessage {
}
impl AdminRequestMessage {
pub fn command(&self) -> LevinCommand {
pub const fn command(&self) -> LevinCommand {
use LevinCommand as C;
match self {
AdminRequestMessage::Handshake(_) => C::Handshake,
AdminRequestMessage::Ping => C::Ping,
AdminRequestMessage::SupportFlags => C::SupportFlags,
AdminRequestMessage::TimedSync(_) => C::TimedSync,
Self::Handshake(_) => C::Handshake,
Self::Ping => C::Ping,
Self::SupportFlags => C::SupportFlags,
Self::TimedSync(_) => C::TimedSync,
}
}
@ -286,13 +282,13 @@ impl AdminRequestMessage {
cuprate_epee_encoding::from_bytes::<EmptyMessage, _>(buf)
.map_err(|e| BucketError::BodyDecodingError(e.into()))?;
AdminRequestMessage::Ping
Self::Ping
}
C::SupportFlags => {
cuprate_epee_encoding::from_bytes::<EmptyMessage, _>(buf)
.map_err(|e| BucketError::BodyDecodingError(e.into()))?;
AdminRequestMessage::SupportFlags
Self::SupportFlags
}
_ => return Err(BucketError::UnknownCommand),
})
@ -302,11 +298,11 @@ impl AdminRequestMessage {
use LevinCommand as C;
match self {
AdminRequestMessage::Handshake(val) => build_message(C::Handshake, val, builder)?,
AdminRequestMessage::TimedSync(val) => build_message(C::TimedSync, val, builder)?,
AdminRequestMessage::Ping => build_message(C::Ping, EmptyMessage, builder)?,
AdminRequestMessage::SupportFlags => {
build_message(C::SupportFlags, EmptyMessage, builder)?
Self::Handshake(val) => build_message(C::Handshake, val, builder)?,
Self::TimedSync(val) => build_message(C::TimedSync, val, builder)?,
Self::Ping => build_message(C::Ping, EmptyMessage, builder)?,
Self::SupportFlags => {
build_message(C::SupportFlags, EmptyMessage, builder)?;
}
}
Ok(())
@ -322,14 +318,14 @@ pub enum AdminResponseMessage {
}
impl AdminResponseMessage {
pub fn command(&self) -> LevinCommand {
pub const fn command(&self) -> LevinCommand {
use LevinCommand as C;
match self {
AdminResponseMessage::Handshake(_) => C::Handshake,
AdminResponseMessage::Ping(_) => C::Ping,
AdminResponseMessage::SupportFlags(_) => C::SupportFlags,
AdminResponseMessage::TimedSync(_) => C::TimedSync,
Self::Handshake(_) => C::Handshake,
Self::Ping(_) => C::Ping,
Self::SupportFlags(_) => C::SupportFlags,
Self::TimedSync(_) => C::TimedSync,
}
}
@ -349,11 +345,11 @@ impl AdminResponseMessage {
use LevinCommand as C;
match self {
AdminResponseMessage::Handshake(val) => build_message(C::Handshake, val, builder)?,
AdminResponseMessage::TimedSync(val) => build_message(C::TimedSync, val, builder)?,
AdminResponseMessage::Ping(val) => build_message(C::Ping, val, builder)?,
AdminResponseMessage::SupportFlags(val) => {
build_message(C::SupportFlags, val, builder)?
Self::Handshake(val) => build_message(C::Handshake, val, builder)?,
Self::TimedSync(val) => build_message(C::TimedSync, val, builder)?,
Self::Ping(val) => build_message(C::Ping, val, builder)?,
Self::SupportFlags(val) => {
build_message(C::SupportFlags, val, builder)?;
}
}
Ok(())
@ -368,23 +364,23 @@ pub enum Message {
}
impl Message {
pub fn is_request(&self) -> bool {
matches!(self, Message::Request(_))
pub const fn is_request(&self) -> bool {
matches!(self, Self::Request(_))
}
pub fn is_response(&self) -> bool {
matches!(self, Message::Response(_))
pub const fn is_response(&self) -> bool {
matches!(self, Self::Response(_))
}
pub fn is_protocol(&self) -> bool {
matches!(self, Message::Protocol(_))
pub const fn is_protocol(&self) -> bool {
matches!(self, Self::Protocol(_))
}
pub fn command(&self) -> LevinCommand {
pub const fn command(&self) -> LevinCommand {
match self {
Message::Request(mes) => mes.command(),
Message::Response(mes) => mes.command(),
Message::Protocol(mes) => mes.command(),
Self::Request(mes) => mes.command(),
Self::Response(mes) => mes.command(),
Self::Protocol(mes) => mes.command(),
}
}
}
@ -398,27 +394,25 @@ impl LevinBody for Message {
command: LevinCommand,
) -> Result<Self, BucketError> {
Ok(match typ {
MessageType::Request => Message::Request(AdminRequestMessage::decode(body, command)?),
MessageType::Response => {
Message::Response(AdminResponseMessage::decode(body, command)?)
}
MessageType::Notification => Message::Protocol(ProtocolMessage::decode(body, command)?),
MessageType::Request => Self::Request(AdminRequestMessage::decode(body, command)?),
MessageType::Response => Self::Response(AdminResponseMessage::decode(body, command)?),
MessageType::Notification => Self::Protocol(ProtocolMessage::decode(body, command)?),
})
}
fn encode(self, builder: &mut BucketBuilder<LevinCommand>) -> Result<(), BucketError> {
match self {
Message::Protocol(pro) => {
Self::Protocol(pro) => {
builder.set_message_type(MessageType::Notification);
builder.set_return_code(0);
pro.build(builder)
}
Message::Request(req) => {
Self::Request(req) => {
builder.set_message_type(MessageType::Request);
builder.set_return_code(0);
req.build(builder)
}
Message::Response(res) => {
Self::Response(res) => {
builder.set_message_type(MessageType::Response);
builder.set_return_code(1);
res.build(builder)

8
net/wire/src/p2p/admin.rs
View file

@ -45,7 +45,7 @@ pub struct HandshakeResponse {
pub node_data: BasicNodeData,
/// Core Sync Data
pub payload_data: CoreSyncData,
/// PeerList
/// `PeerList`
pub local_peerlist_new: Vec<PeerListEntryBase>,
}
@ -56,7 +56,7 @@ epee_object!(
local_peerlist_new: Vec<PeerListEntryBase>,
);
/// A TimedSync Request
/// A `TimedSync` Request
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TimedSyncRequest {
/// Core Sync Data
@ -68,12 +68,12 @@ epee_object!(
payload_data: CoreSyncData,
);
/// A TimedSync Response
/// A `TimedSync` Response
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TimedSyncResponse {
/// Core Sync Data
pub payload_data: CoreSyncData,
/// PeerList
/// `PeerList`
pub local_peerlist_new: Vec<PeerListEntryBase>,
}

16
net/wire/src/p2p/common.rs
View file

@ -18,6 +18,7 @@
use bitflags::bitflags;
use cuprate_epee_encoding::epee_object;
use cuprate_helper::map::split_u128_into_low_high_bits;
pub use cuprate_types::{BlockCompleteEntry, PrunedTxBlobEntry, TransactionBlobs};
use crate::NetworkAddress;
@ -34,7 +35,7 @@ bitflags! {
impl From<u32> for PeerSupportFlags {
fn from(value: u32) -> Self {
PeerSupportFlags(value)
Self(value)
}
}
@ -113,16 +114,17 @@ epee_object! {
}
impl CoreSyncData {
pub fn new(
pub const fn new(
cumulative_difficulty_128: u128,
current_height: u64,
pruning_seed: u32,
top_id: [u8; 32],
top_version: u8,
) -> CoreSyncData {
let cumulative_difficulty = cumulative_difficulty_128 as u64;
let cumulative_difficulty_top64 = (cumulative_difficulty_128 >> 64) as u64;
CoreSyncData {
) -> Self {
let (cumulative_difficulty, cumulative_difficulty_top64) =
split_u128_into_low_high_bits(cumulative_difficulty_128);
Self {
cumulative_difficulty,
cumulative_difficulty_top64,
current_height,
@ -139,7 +141,7 @@ impl CoreSyncData {
}
}
/// PeerListEntryBase, information kept on a peer which will be entered
/// `PeerListEntryBase`, information kept on a peer which will be entered
/// in a peer list/store.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PeerListEntryBase {

6
net/wire/src/p2p/protocol.rs
View file

@ -127,7 +127,7 @@ pub struct ChainResponse {
impl ChainResponse {
#[inline]
pub fn cumulative_difficulty(&self) -> u128 {
pub const fn cumulative_difficulty(&self) -> u128 {
let cumulative_difficulty = self.cumulative_difficulty_top64 as u128;
cumulative_difficulty << 64 | self.cumulative_difficulty_low64 as u128
}
@ -159,7 +159,7 @@ epee_object!(
current_blockchain_height: u64,
);
/// A request for Txs we are missing from our TxPool
/// A request for Txs we are missing from our `TxPool`
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FluffyMissingTransactionsRequest {
/// The Block we are missing the Txs in
@ -177,7 +177,7 @@ epee_object!(
missing_tx_indices: Vec<u64> as ContainerAsBlob<u64>,
);
/// TxPoolCompliment
/// `TxPoolCompliment`
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GetTxPoolCompliment {
/// Tx Hashes