Merge pull request #662 from pragma-org/tidy-kernel

chore: tidy kernel modules

Author: rkuhn

Cargo.lock

@@ -23,7 +23,6 @@ async-trait.workspace = true
 hex.workspace = true
 itertools.workspace = true
 opentelemetry.workspace = true
-pallas-crypto.workspace = true
 parking_lot.workspace = true
 proptest = { workspace = true, optional = true }
 rand = { workspace = true, optional = true }
@@ -41,7 +40,6 @@ amaru-mempool.workspace = true
 amaru-metrics.workspace = true
 amaru-ouroboros-traits.workspace = true
 amaru-protocols.workspace = true
-amaru-slot-arithmetic.workspace = true
 pure-stage.workspace = true
 
 [dev-dependencies]

crates/amaru-consensus/Cargo.toml

@@ -29,18 +29,20 @@
 #[expect(clippy::unwrap_used)]
 #[cfg(all(unix, feature = "profiling", feature = "test-utils"))]
 fn main() {
-    use amaru_consensus::consensus::headers_tree::HeadersTree;
-    use amaru_consensus::consensus::headers_tree::data_generation::{
-        execute_actions_on_tree, generate_random_walks, generate_tree_of_headers,
+    use amaru_consensus::consensus::{
+        headers_tree::{
+            HeadersTree,
+            data_generation::{
+                execute_actions_on_tree, generate_random_walks, generate_tree_of_headers,
+            },
+        },
+        stages::select_chain::DEFAULT_MAXIMUM_FRAGMENT_LENGTH,
     };
-    use amaru_consensus::consensus::stages::select_chain::DEFAULT_MAXIMUM_FRAGMENT_LENGTH;
     use amaru_kernel::{BlockHeader, IsHeader};
-    use amaru_ouroboros_traits::ChainStore;
-    use amaru_ouroboros_traits::in_memory_consensus_store::InMemConsensusStore;
+    use amaru_ouroboros_traits::{ChainStore, in_memory_consensus_store::InMemConsensusStore};
     use amaru_stores::rocksdb::{RocksDbConfig, consensus::RocksDBStore};
     use pprof::{ProfilerGuardBuilder, flamegraph::Options};
-    use std::fs::File;
-    use std::sync::Arc;
+    use std::{fs::File, sync::Arc};
 
     let profile = false;
     let in_memory = false;

crates/amaru-consensus/benches/headers_tree.rs

@@ -16,7 +16,7 @@ use crate::consensus::effects::{
     Base, BaseOps, Ledger, LedgerOps, Network, NetworkOps, Store,
     metrics_effects::{Metrics, MetricsOps},
 };
-use amaru_kernel::{BlockHeader, Tx};
+use amaru_kernel::{BlockHeader, Transaction};
 use amaru_ouroboros_traits::{ChainStore, TxSubmissionMempool};
 use amaru_protocols::mempool_effects::MemoryPool;
 use pure_stage::{Effects, SendData};
@@ -30,7 +30,7 @@ pub trait ConsensusOps: Send + Sync + Clone {
     fn network(&self) -> impl NetworkOps;
     /// Return a TxSubmissionMempool implementation to access mempool operations, like get_tx to retrieve a transaction
     /// from the mempool.
-    fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Tx>>;
+    fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Transaction>>;
     /// Return a LedgerOps implementation to access ledger operations, considering that it is a sub-system
     /// external to consensus.
     fn ledger(&self) -> Arc<dyn LedgerOps>;
@@ -55,7 +55,7 @@ impl<T: SendData + Sync + Clone> ConsensusEffects<T> {
         Arc::new(Store::new(self.effects.clone()))
     }
 
-    pub fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Tx>> {
+    pub fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Transaction>> {
         Arc::new(MemoryPool::new(self.effects.clone()))
     }
 
@@ -81,7 +81,7 @@ impl<T: SendData + Sync + Clone> ConsensusOps for ConsensusEffects<T> {
         self.store()
     }
 
-    fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Tx>> {
+    fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Transaction>> {
         self.mempool()
     }
 
@@ -107,33 +107,28 @@ impl<T: SendData + Sync + Clone> ConsensusOps for ConsensusEffects<T> {
 pub mod tests {
     use super::*;
     use crate::consensus::errors::ProcessingFailed;
-    use amaru_kernel::peer::Peer;
-    use amaru_kernel::protocol_messages::tip::Tip;
-    use amaru_kernel::{Point, PoolId, RawBlock};
+    use amaru_kernel::{Peer, Point, PoolId, RawBlock, Tip};
     use amaru_mempool::strategies::InMemoryMempool;
-    use amaru_metrics::MetricsEvent;
-    use amaru_metrics::ledger::LedgerMetrics;
+    use amaru_metrics::{MetricsEvent, ledger::LedgerMetrics};
     use amaru_ouroboros::has_stake_distribution::GetPoolError;
-    use amaru_ouroboros_traits::can_validate_blocks::HeaderValidationError;
-    use amaru_ouroboros_traits::in_memory_consensus_store::InMemConsensusStore;
     use amaru_ouroboros_traits::{
         BlockValidationError, HasStakeDistribution, PoolSummary, TxSubmissionMempool,
+        can_validate_blocks::HeaderValidationError, in_memory_consensus_store::InMemConsensusStore,
     };
     use amaru_protocols::blockfetch::Blocks;
     use amaru_slot_arithmetic::Slot;
     use parking_lot::Mutex;
-    use pure_stage::serde::{from_cbor, to_cbor};
-    use pure_stage::{BoxFuture, Instant, StageRef};
+    use pure_stage::{
+        BoxFuture, Instant, StageRef,
+        serde::{from_cbor, to_cbor},
+    };
     use serde::de::DeserializeOwned;
-    use std::collections::BTreeMap;
-    use std::future::ready;
-    use std::sync::Arc;
-    use std::time::Duration;
+    use std::{collections::BTreeMap, future::ready, sync::Arc, time::Duration};
 
     #[derive(Clone)]
     pub struct MockConsensusOps {
         pub mock_store: InMemConsensusStore<BlockHeader>,
-        pub mock_mempool: Arc<dyn TxSubmissionMempool<Tx>>,
+        pub mock_mempool: Arc<dyn TxSubmissionMempool<Transaction>>,
         pub mock_network: MockNetworkOps,
         pub mock_ledger: MockLedgerOps,
         pub mock_base: MockBaseOps,
@@ -150,7 +145,7 @@ pub mod tests {
             self.mock_network.clone()
         }
 
-        fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Tx>> {
+        fn mempool(&self) -> Arc<dyn TxSubmissionMempool<Transaction>> {
             self.mock_mempool.clone()
         }
 

crates/amaru-consensus/src/consensus/effects/consensus_effects.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use crate::consensus::errors::ProcessingFailed;
-use amaru_kernel::{BlockHeader, IgnoreEq, Point, RawBlock, peer::Peer};
+use amaru_kernel::{BlockHeader, IgnoreEq, Peer, Point, RawBlock};
 use amaru_metrics::ledger::LedgerMetrics;
 use amaru_ouroboros_traits::{
     BlockValidationError, CanValidateBlocks,

crates/amaru-consensus/src/consensus/effects/ledger_effects.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use crate::consensus::errors::ProcessingFailed;
-use amaru_kernel::{BlockHeader, IsHeader, Point, peer::Peer, protocol_messages::tip::Tip};
+use amaru_kernel::{BlockHeader, IsHeader, Peer, Point, Tip};
 use anyhow::anyhow;
 use async_trait::async_trait;
 use pure_stage::{BoxFuture, Effects, ExternalEffect, ExternalEffectAPI, Resources, SendData};

crates/amaru-consensus/src/consensus/effects/network_effects.rs

@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use amaru_kernel::{
-    BlockHeader, HeaderHash, Point, RawBlock, protocol_parameters::GlobalParameters,
-};
+use amaru_kernel::{BlockHeader, GlobalParameters, HeaderHash, Point, RawBlock};
 use amaru_ouroboros_traits::{ChainStore, Nonces, ReadOnlyChainStore, StoreError};
 use pure_stage::{
     BoxFuture, Effects, ExternalEffect, ExternalEffectAPI, ExternalEffectSync, Resources, SendData,

crates/amaru-consensus/src/consensus/effects/store_effects.rs

@@ -13,14 +13,10 @@
 // limitations under the License.
 
 use crate::consensus;
-use amaru_kernel::peer::Peer;
-use amaru_kernel::{HeaderHash, Point};
-use amaru_ouroboros_traits::StoreError;
-use amaru_ouroboros_traits::can_validate_blocks::HeaderValidationError;
+use amaru_kernel::{HeaderHash, Peer, Point};
+use amaru_ouroboros_traits::{StoreError, can_validate_blocks::HeaderValidationError};
 use serde::ser::SerializeStruct;
-use serde::{Deserialize, Serialize};
-use std::fmt;
-use std::fmt::Display;
+use std::{fmt, fmt::Display};
 use thiserror::Error;
 
 #[derive(Error, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
@@ -141,7 +137,7 @@ impl PartialEq for ProcessingFailed {
     }
 }
 
-impl Serialize for ProcessingFailed {
+impl serde::Serialize for ProcessingFailed {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -153,12 +149,12 @@ impl Serialize for ProcessingFailed {
     }
 }
 
-impl<'de> Deserialize<'de> for ProcessingFailed {
+impl<'de> serde::Deserialize<'de> for ProcessingFailed {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        #[derive(Deserialize)]
+        #[derive(serde::Deserialize)]
         struct ProcessingFailedHelper {
             peer: Option<Peer>,
             error: String,

crates/amaru-consensus/src/consensus/errors.rs

@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::protocol_messages::tip::Tip;
-use crate::{BlockHeader, IsHeader, Point, RawBlock, peer::Peer};
-use serde::{Deserialize, Serialize};
-use std::fmt;
-use std::fmt::{Debug, Formatter};
+use amaru_kernel::{BlockHeader, IsHeader, Peer, Point, RawBlock, Tip};
+use std::{
+    fmt,
+    fmt::{Debug, Formatter},
+};
 use tracing::Span;
 
 /// Wrapper type to factor out caught-up messages from real events.
@@ -174,7 +174,7 @@ pub enum ValidateHeaderEvent {
     },
 }
 
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 pub enum ValidateBlockEvent {
     Validated {
         peer: Peer,
@@ -255,7 +255,7 @@ impl PartialEq for ValidateBlockEvent {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum BlockValidationResult {
     BlockValidated {
         peer: Peer,