diff --git a/src/kerberos/mod.rs b/src/kerberos/mod.rs
index cc48eaf..8fb46fa 100644
--- a/src/kerberos/mod.rs
+++ b/src/kerberos/mod.rs
@@ -71,7 +71,7 @@ impl KerberosDateTime{
 
     #[inline]
     pub fn get_year(&self) -> u64{
-        ((self.0 >> 26) & 0xFFFFFFFF)
+        (self.0 >> 26) & 0xFFFFFFFF
     }
 
     pub fn to_regular_time(&self) -> chrono::DateTime<Utc>{
diff --git a/src/main.rs b/src/main.rs
index 04423f0..d2e3625 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,12 +7,11 @@ use std::net::{Ipv4Addr, SocketAddrV4};
 use std::sync::Arc;
 use chrono::Local;
 use log::info;
-use macros::RmcSerialize;
 use once_cell::sync::Lazy;
 use rc4::{KeyInit, Rc4, StreamCipher};
 use rc4::consts::U5;
 use simplelog::{ColorChoice, CombinedLogger, Config, LevelFilter, TerminalMode, TermLogger, WriteLogger};
-use tokio::sync::{Mutex, RwLock};
+use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 use crate::nex::account::Account;
 use crate::protocols::{auth, block_if_maintenance};
@@ -20,12 +19,11 @@ use crate::protocols::auth::AuthProtocolConfig;
 use crate::protocols::matchmake_common::MatchmakeData;
 use crate::protocols::server::RMCProtocolServer;
 use crate::prudp::socket::{ActiveSecureConnectionData, EncryptionPair, Socket};
-use crate::prudp::packet::{PRUDPPacket, VirtualPort};
+use crate::prudp::packet::{VirtualPort};
 use crate::prudp::router::Router;
 use crate::prudp::secure::{generate_secure_encryption_pairs, read_secure_connection_data};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::structures::RmcSerialize;
-use crate::rmc::structures::variant::Variant;
 
 mod endianness;
 mod prudp;
@@ -121,7 +119,7 @@ async fn start_auth_server() -> AuthServer{
         Box::new(auth::bound_protocol(auth_protocol_config))
     ]));
 
-    let mut socket =
+    let socket =
         Socket::new(
             router.clone(),
             VirtualPort::new(1,10),
@@ -131,7 +129,7 @@ async fn start_auth_server() -> AuthServer{
                     async move {
 
 
-                        let encryption_pairs = Vec::from_iter((0..=count).map(|v| {
+                        let encryption_pairs = Vec::from_iter((0..=count).map(|_v| {
                             let rc4: Rc4<U5> = Rc4::new_from_slice( "CD&ML".as_bytes()).unwrap();
                             let cypher = Box::new(rc4);
                             let server_cypher: Box<dyn StreamCipher + Send> = cypher;
@@ -191,7 +189,7 @@ async fn start_secure_server() -> SecureServer{
         Box::new(protocols::matchmake_extension::bound_protocol(matchmake_data))
     ]));
 
-    let mut socket =
+    let socket =
         Socket::new(
             router.clone(),
             VirtualPort::new(1,10),
diff --git a/src/protocols/auth/method_login.rs b/src/protocols/auth/method_login.rs
index 8e20a0c..d2c1642 100644
--- a/src/protocols/auth/method_login.rs
+++ b/src/protocols/auth/method_login.rs
@@ -2,7 +2,6 @@ use std::io::Cursor;
 use std::sync::Arc;
 use log::error;
 use tokio::sync::Mutex;
-use crate::nex::account::Account;
 use crate::protocols::auth::AuthProtocolConfig;
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::rmc::message::RMCMessage;
@@ -15,7 +14,7 @@ pub async fn login(rmcmessage: &RMCMessage, _name: &str) -> RMCResponseResult{
     rmcmessage.error_result_with_code(ErrorCode::Core_NotImplemented)
 }
 
-pub async fn login_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, _: &Arc<Mutex<ConnectionData>>, data: AuthProtocolConfig) -> RMCResponseResult{
+pub async fn login_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, _: &Arc<Mutex<ConnectionData>>, _data: AuthProtocolConfig) -> RMCResponseResult{
     let mut reader = Cursor::new(&rmcmessage.rest_of_data);
 
     let Ok(str) = String::deserialize(&mut reader) else {
diff --git a/src/protocols/auth/method_login_ex.rs b/src/protocols/auth/method_login_ex.rs
index 61ed0c7..63ff73f 100644
--- a/src/protocols/auth/method_login_ex.rs
+++ b/src/protocols/auth/method_login_ex.rs
@@ -1,12 +1,10 @@
 use std::io::{Cursor, Write};
 use std::sync::Arc;
 use bytemuck::bytes_of;
-use hex::encode;
 use log::{error};
 use tokio::sync::Mutex;
 use crate::grpc::account;
 use crate::kerberos::KerberosDateTime;
-use crate::nex::account::Account;
 use crate::protocols::auth::AuthProtocolConfig;
 use crate::protocols::auth::ticket_generation::generate_ticket;
 use crate::prudp::socket::{ConnectionData, SocketData};
diff --git a/src/protocols/auth/method_request_ticket.rs b/src/protocols/auth/method_request_ticket.rs
index 6a04041..6f2d767 100644
--- a/src/protocols/auth/method_request_ticket.rs
+++ b/src/protocols/auth/method_request_ticket.rs
@@ -1,17 +1,13 @@
 use std::io::Cursor;
 use std::sync::Arc;
-use log::error;
 use tokio::sync::Mutex;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
-use crate::grpc::account;
 use crate::protocols::auth::{AuthProtocolConfig, get_login_data_by_pid};
-use crate::protocols::auth::method_login_ex::login_ex;
 use crate::protocols::auth::ticket_generation::generate_ticket;
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::response::{ErrorCode, RMCResponseResult};
 use crate::rmc::response::ErrorCode::Core_Unknown;
-use crate::rmc::structures::any::Any;
 use crate::rmc::structures::qresult::QResult;
 use crate::rmc::structures::RmcSerialize;
 
diff --git a/src/protocols/auth/mod.rs b/src/protocols/auth/mod.rs
index 9f54532..1cc4f87 100644
--- a/src/protocols/auth/mod.rs
+++ b/src/protocols/auth/mod.rs
@@ -3,16 +3,12 @@ mod method_login;
 mod ticket_generation;
 mod method_request_ticket;
 
-use std::sync::Arc;
-use log::{error};
 use crate::define_protocol;
 use crate::grpc::account;
 use crate::nex::account::Account;
 use crate::protocols::auth::method_login::login_raw_params;
 use crate::protocols::auth::method_login_ex::login_ex_raw_params;
 use crate::protocols::auth::method_request_ticket::request_ticket_raw_params;
-use crate::rmc::message::RMCMessage;
-use crate::rmc::response::{ErrorCode, RMCResponse};
 
 #[derive(Copy, Clone)]
 pub struct AuthProtocolConfig {
diff --git a/src/protocols/matchmake/method_unregister_gathering.rs b/src/protocols/matchmake/method_unregister_gathering.rs
index 28f9c5b..d055afb 100644
--- a/src/protocols/matchmake/method_unregister_gathering.rs
+++ b/src/protocols/matchmake/method_unregister_gathering.rs
@@ -1,6 +1,5 @@
 use std::io::Cursor;
 use std::sync::Arc;
-use log::info;
 use tokio::sync::{Mutex, RwLock};
 use crate::protocols::matchmake_common::MatchmakeData;
 use crate::prudp::socket::{ConnectionData, SocketData};
diff --git a/src/protocols/matchmake_common/mod.rs b/src/protocols/matchmake_common/mod.rs
index ce725e2..79f7c97 100644
--- a/src/protocols/matchmake_common/mod.rs
+++ b/src/protocols/matchmake_common/mod.rs
@@ -1,4 +1,4 @@
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap};
 use std::sync::Arc;
 use log::error;
 use tokio::sync::Mutex;
diff --git a/src/protocols/matchmake_extension/method_auto_matchmake_with_param_postpone.rs b/src/protocols/matchmake_extension/method_auto_matchmake_with_param_postpone.rs
index 47da00b..2d53080 100644
--- a/src/protocols/matchmake_extension/method_auto_matchmake_with_param_postpone.rs
+++ b/src/protocols/matchmake_extension/method_auto_matchmake_with_param_postpone.rs
@@ -6,7 +6,7 @@ use crate::protocols::matchmake_common::{ExtendedMatchmakeSession, MatchmakeData
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::response::{ErrorCode, RMCResponseResult};
-use crate::rmc::structures::matchmake::{AutoMatchmakeParam, MatchmakeSession};
+use crate::rmc::structures::matchmake::{AutoMatchmakeParam};
 use crate::rmc::structures::RmcSerialize;
 
 
diff --git a/src/protocols/matchmake_extension/method_get_playing_session.rs b/src/protocols/matchmake_extension/method_get_playing_session.rs
index ff784d9..bc4eb3c 100644
--- a/src/protocols/matchmake_extension/method_get_playing_session.rs
+++ b/src/protocols/matchmake_extension/method_get_playing_session.rs
@@ -10,7 +10,7 @@ use crate::rmc::structures::RmcSerialize;
 
 type PIDList = Vec<u32>;
 
-async fn get_playing_session(rmcmessage: &RMCMessage, data: Arc<RwLock<MatchmakeData>>) -> RMCResponseResult {
+async fn get_playing_session(rmcmessage: &RMCMessage, _data: Arc<RwLock<MatchmakeData>>) -> RMCResponseResult {
     //todo: propperly implement this
 
     let cheeseburger = PIDList::new();
diff --git a/src/protocols/matchmake_extension/mod.rs b/src/protocols/matchmake_extension/mod.rs
index 080db7b..509f3bb 100644
--- a/src/protocols/matchmake_extension/mod.rs
+++ b/src/protocols/matchmake_extension/mod.rs
@@ -2,7 +2,7 @@ mod method_get_playing_session;
 mod method_auto_matchmake_with_param_postpone;
 
 use std::sync::Arc;
-use tokio::sync::{Mutex, RwLock};
+use tokio::sync::{RwLock};
 use crate::define_protocol;
 use crate::protocols::matchmake_common::MatchmakeData;
 use method_get_playing_session::get_playing_session_raw_params;
diff --git a/src/protocols/mod.rs b/src/protocols/mod.rs
index 9f0f188..89916af 100644
--- a/src/protocols/mod.rs
+++ b/src/protocols/mod.rs
@@ -35,7 +35,7 @@ static BYPASS_LEVEL: Lazy<i32> = Lazy::new(|| {
 
 pub fn block_if_maintenance<'a>(rmcmessage: &'a RMCMessage, _: &'a Arc<SocketData> , conn: &'a Arc<Mutex<ConnectionData>>) -> Pin<Box<(dyn Future<Output=Option<RMCResponse>> + Send + 'a)>> {
     Box::pin(async move {
-        let mut conn = conn.lock().await;
+        let conn = conn.lock().await;
 
         if let Some(active_conn) = conn.active_connection_data.as_ref() {
             if let Some(secure_conn) = active_conn.active_secure_connection_data.as_ref() {
diff --git a/src/protocols/secure/method_register.rs b/src/protocols/secure/method_register.rs
index eb99421..fcfb438 100644
--- a/src/protocols/secure/method_register.rs
+++ b/src/protocols/secure/method_register.rs
@@ -1,22 +1,19 @@
 use std::io::{Cursor, Write};
 use std::sync::Arc;
 use bytemuck::bytes_of;
-use log::{error, warn};
 use tokio::sync::Mutex;
-use crate::protocols::auth::AuthProtocolConfig;
 use crate::prudp::socket::{ConnectionData, SocketData};
 use crate::prudp::station_url::{nat_types, StationUrl};
 use crate::prudp::station_url::Type::PRUDPS;
 use crate::prudp::station_url::UrlOptions::{Address, NatFiltering, NatMapping, NatType, Port, PrincipalID, RVConnectionID};
 use crate::rmc::message::RMCMessage;
 use crate::rmc::response::{ErrorCode, RMCResponseResult};
-use crate::rmc::structures::any::Any;
 use crate::rmc::structures::qresult::QResult;
 use crate::rmc::structures::RmcSerialize;
 
 type StringList = Vec<String>;
 
-pub async fn register(rmcmessage: &RMCMessage, station_urls: Vec<StationUrl>, conn_data: &Arc<Mutex<ConnectionData>>) -> RMCResponseResult{
+pub async fn register(rmcmessage: &RMCMessage, _station_urls: Vec<StationUrl>, conn_data: &Arc<Mutex<ConnectionData>>) -> RMCResponseResult{
     let locked = conn_data.lock().await;
     let Some(active_connection_data) = locked.active_connection_data.as_ref() else {
         return rmcmessage.error_result_with_code(ErrorCode::RendezVous_NotAuthenticated)
diff --git a/src/protocols/secure/method_send_report.rs b/src/protocols/secure/method_send_report.rs
index 6b8b44f..81322f9 100644
--- a/src/protocols/secure/method_send_report.rs
+++ b/src/protocols/secure/method_send_report.rs
@@ -3,11 +3,9 @@ use std::sync::Arc;
 use log::error;
 use tokio::sync::Mutex;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
-use crate::protocols::secure::method_register::register;
 use crate::prudp::socket::{ConnectionData, SocketData};
-use crate::prudp::station_url::StationUrl;
 use crate::rmc::message::RMCMessage;
-use crate::rmc::response::{ErrorCode, RMCResponseResult};
+use crate::rmc::response::{RMCResponseResult};
 use crate::rmc::response::ErrorCode::Core_InvalidArgument;
 use crate::rmc::structures::qbuffer;
 
@@ -22,7 +20,7 @@ pub async fn send_report(rmcmessage: &RMCMessage, report_id: u32, data: Vec<u8>)
     return rmcmessage.success_with_data(Vec::new());
 }
 
-pub async fn send_report_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, conn_data: &Arc<Mutex<ConnectionData>>, _: ()) -> RMCResponseResult{
+pub async fn send_report_raw_params(rmcmessage: &RMCMessage, _: &Arc<SocketData>, _conn_data: &Arc<Mutex<ConnectionData>>, _: ()) -> RMCResponseResult{
     let mut reader = Cursor::new(&rmcmessage.rest_of_data);
 
     let Ok(error_id) = reader.read_struct(IS_BIG_ENDIAN) else {
diff --git a/src/prudp/secure.rs b/src/prudp/secure.rs
index 01f2055..916971d 100644
--- a/src/prudp/secure.rs
+++ b/src/prudp/secure.rs
@@ -7,7 +7,6 @@ use rc4::consts::U16;
 use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
 use crate::kerberos::{derive_key, TicketInternalData};
 use crate::nex::account::Account;
-use crate::prudp::packet::PRUDPHeader;
 use crate::prudp::socket::EncryptionPair;
 use crate::rmc::structures::RmcSerialize;
 
diff --git a/src/prudp/socket.rs b/src/prudp/socket.rs
index f32528b..ecf0108 100644
--- a/src/prudp/socket.rs
+++ b/src/prudp/socket.rs
@@ -4,8 +4,8 @@ use std::ops::Deref;
 use std::pin::Pin;
 use tokio::net::UdpSocket;
 use std::sync::{Arc};
-use tokio::sync::{Mutex, MutexGuard, RwLock};
-use log::{error, info, trace, warn};
+use tokio::sync::{Mutex, RwLock};
+use log::{error, trace, warn};
 use rand::random;
 use rc4::StreamCipher;
 use crate::prudp::packet::{PacketOption, PRUDPPacket, VirtualPort};
diff --git a/src/rmc/response.rs b/src/rmc/response.rs
index 96b82f3..7d16ba4 100644
--- a/src/rmc/response.rs
+++ b/src/rmc/response.rs
@@ -1,7 +1,6 @@
 use std::io;
 use std::io::{Write};
 use std::mem::transmute;
-use std::time::Duration;
 use bytemuck::bytes_of;
 use crate::prudp::packet::{PRUDPPacket};
 use crate::prudp::packet::flags::{NEED_ACK, RELIABLE};
diff --git a/src/rmc/structures/buffer.rs b/src/rmc/structures/buffer.rs
index 19639fc..aea5a45 100644
--- a/src/rmc/structures/buffer.rs
+++ b/src/rmc/structures/buffer.rs
@@ -1,5 +1,4 @@
 use std::io::{Read, Write};
-use crate::endianness::{IS_BIG_ENDIAN, ReadExtensions};
 use crate::rmc::structures::RmcSerialize;
 
 impl<'a> RmcSerialize for &'a [u8]{
@@ -12,7 +11,7 @@ impl<'a> RmcSerialize for &'a [u8]{
     }
 
     /// DO NOT USE (also maybe split off the serialize and deserialize functions at some point)
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(_reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
         panic!("cannot deserialize to a u8 slice reference (use this ONLY for writing)")
     }
 }
diff --git a/src/rmc/structures/connection_data.rs b/src/rmc/structures/connection_data.rs
index 2527c1b..de20491 100644
--- a/src/rmc/structures/connection_data.rs
+++ b/src/rmc/structures/connection_data.rs
@@ -12,7 +12,7 @@ pub struct ConnectionData<'a>{
 
 impl<'a> RmcSerialize for ConnectionData<'a>{
     fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
-        rmc_struct::write_struct(writer, 1, |mut v|{
+        rmc_struct::write_struct(writer, 1, |v|{
             self.station_url.serialize(v).expect("unable to write station url");
             self.special_protocols.serialize(v).expect("unable to write special protocols");
             self.special_station_url.serialize(v).expect("unable to write special station url");
@@ -22,7 +22,7 @@ impl<'a> RmcSerialize for ConnectionData<'a>{
         })
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(_reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
         todo!()
     }
 }
diff --git a/src/rmc/structures/matchmake.rs b/src/rmc/structures/matchmake.rs
index 5406512..72cb6a0 100644
--- a/src/rmc/structures/matchmake.rs
+++ b/src/rmc/structures/matchmake.rs
@@ -1,6 +1,5 @@
 use macros::RmcSerialize;
 use crate::kerberos::KerberosDateTime;
-use crate::rmc::structures::RmcSerialize;
 use crate::rmc::structures::variant::Variant;
 
 // rmc structure
diff --git a/src/rmc/structures/primitives.rs b/src/rmc/structures/primitives.rs
index 8de5458..bd08da8 100644
--- a/src/rmc/structures/primitives.rs
+++ b/src/rmc/structures/primitives.rs
@@ -72,7 +72,7 @@ impl RmcSerialize for bool{
         Ok(())
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
         Ok(u8::deserialize(reader)? != 0)
     }
 }
diff --git a/src/rmc/structures/rmc_struct.rs b/src/rmc/structures/rmc_struct.rs
index fc4c944..2477315 100644
--- a/src/rmc/structures/rmc_struct.rs
+++ b/src/rmc/structures/rmc_struct.rs
@@ -10,7 +10,7 @@ struct StructureHeader{
     length: u32
 }
 
-pub fn write_struct(mut writer: &mut dyn Write, version: u8, pred: impl FnOnce(&mut Vec<u8>) -> Result<()> ) -> Result<()> {
+pub fn write_struct(writer: &mut dyn Write, version: u8, pred: impl FnOnce(&mut Vec<u8>) -> Result<()> ) -> Result<()> {
     writer.write_all(&[version])?;
 
     let mut scratch_space: Vec<u8> = Vec::new();
diff --git a/src/rmc/structures/string.rs b/src/rmc/structures/string.rs
index f2c63f1..712da2c 100644
--- a/src/rmc/structures/string.rs
+++ b/src/rmc/structures/string.rs
@@ -23,7 +23,7 @@ impl RmcSerialize for String{
 }
 
 impl RmcSerialize for &str{
-    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(_reader: &mut dyn Read) -> Result<Self> {
         panic!("cannot serialize to &str")
     }
     fn serialize(&self, writer: &mut dyn Write) -> Result<()> {