Merge branch 'main' into cast

2024-11-16 15:58:14 +00:00 · 2024-11-12 17:04:14 -05:00 · 2024-11-12 17:04:14 -05:00 · cb2f2f81fb
commit cb2f2f81fb
parent 2ee3bc34de 5a5f88cb13
87 changed files with 1547 additions and 970 deletions
--- a/.github/workflows/audit.yml
+++ b/.github/workflows/audit.yml
@ -1,34 +0,0 @@
-# This runs `cargo audit` on all dependencies (only if Cargo deps changed)
-
-name: Audit
-
-on:
-  push:
-    paths:
-      - '**/Cargo.toml'
-      - '**/Cargo.lock'
-  workflow_dispatch:
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  audit:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Cache
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.cargo
-          target
-        key: audit
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-    - name: Install dependencies
-      run: cargo install cargo-audit --locked
-    - name: Audit
-      run: cargo audit
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -133,7 +133,12 @@ jobs:
    - name: Test
      run: |
        cargo test --all-features --workspace
-        cargo test --package cuprate-blockchain --no-default-features --features redb --features service
+        cargo test --package cuprate-blockchain --no-default-features --features redb
+
+    - name: Hack Check
+      run: |
+        cargo install cargo-hack --locked
+        cargo hack --workspace check --feature-powerset --no-dev-deps

    # TODO: upload binaries with `actions/upload-artifact@v3`
    - name: Build
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -121,11 +121,14 @@ Before pushing your code, please run the following at the root of the repository
 After that, ensure all other CI passes by running:

 | Command                                                                | Does what                                                               |
-|------------------------------------------------------------------------|-----------|
-| `RUSTDOCFLAGS='-D warnings' cargo doc --workspace --all-features`      | Checks documentation is OK
-| `cargo clippy --workspace --all-features --all-targets -- -D warnings` | Checks clippy lints are satisfied
-| `cargo test --all-features --workspace`                                | Runs all tests
-| `cargo build --all-features --all-targets --workspace`                 | Builds all code
+|------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| `RUSTDOCFLAGS='-D warnings' cargo doc --workspace --all-features`      | Checks documentation is OK                                              |
+| `cargo clippy --workspace --all-features --all-targets -- -D warnings` | Checks clippy lints are satisfied                                       |
+| `cargo test --all-features --workspace`                                | Runs all tests                                                          |
+| `cargo build --all-features --all-targets --workspace`                 | Builds all code                                                         |
+| `cargo hack --workspace check --feature-powerset --no-dev-deps`        | Uses `cargo hack` to check our crates build with different features set |
+
+`cargo hack` can be installed with `cargo` from: https://github.com/taiki-e/cargo-hack.

 **Note: in order for some tests to work, you will need to place a [`monerod`](https://www.getmonero.org/downloads/) binary at the root of the repository.**

--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -16,6 +16,7 @@ members = [
 	"net/wire",
 	"p2p/p2p",
 	"p2p/p2p-core",
+	"p2p/bucket",
 	"p2p/dandelion-tower",
 	"p2p/async-buffer",
 	"p2p/address-book",
@ -64,6 +65,7 @@ cuprate-levin               = { path = "net/levin"              ,default-feature
 cuprate-wire                = { path = "net/wire"               ,default-features = false}
 cuprate-p2p                 = { path = "p2p/p2p"                ,default-features = false}
 cuprate-p2p-core            = { path = "p2p/p2p-core"           ,default-features = false}
+cuprate-p2p-bucket          = { path = "p2p/p2p-bucket"         ,default-features = false}
 cuprate-dandelion-tower     = { path = "p2p/dandelion-tower"    ,default-features = false}
 cuprate-async-buffer        = { path = "p2p/async-buffer"       ,default-features = false}
 cuprate-address-book        = { path = "p2p/address-book"       ,default-features = false}
@ -79,54 +81,55 @@ cuprate-rpc-types           = { path = "rpc/types"              ,default-feature
 cuprate-rpc-interface       = { path = "rpc/interface"          ,default-features = false}

 # External dependencies
-anyhow                = { version = "1.0.89", default-features = false }
-async-trait           = { version = "0.1.82", default-features = false }
-bitflags              = { version = "2.6.0", default-features = false }
+anyhow                = { version = "1", default-features = false }
+arrayvec              = { version = "0.7", default-features = false }
+async-trait           = { version = "0.1", default-features = false }
+bitflags              = { version = "2", default-features = false }
 blake3                = { version = "1", default-features = false }
-borsh                 = { version = "1.5.1", default-features = false }
-bytemuck              = { version = "1.18.0", default-features = false }
-bytes                 = { version = "1.7.2", default-features = false }
-cfg-if                = { version = "1.0.0", default-features = false }
-clap                  = { version = "4.5.17", default-features = false }
-chrono                = { version = "0.4.38", default-features = false }
-crypto-bigint         = { version = "0.5.5", default-features = false }
-crossbeam             = { version = "0.8.4", default-features = false }
-const_format          = { version = "0.2.33", default-features = false }
-curve25519-dalek      = { version = "4.1.3", default-features = false }
-dashmap               = { version = "5.5.3", default-features = false }
-dirs                  = { version = "5.0.1", default-features = false }
-futures               = { version = "0.3.30", default-features = false }
-hex                   = { version = "0.4.3", default-features = false }
+borsh                 = { version = "1", default-features = false }
+bytemuck              = { version = "1", default-features = false }
+bytes                 = { version = "1", default-features = false }
+cfg-if                = { version = "1", default-features = false }
+clap                  = { version = "4", default-features = false }
+chrono                = { version = "0.4", default-features = false }
+crypto-bigint         = { version = "0.5", default-features = false }
+crossbeam             = { version = "0.8", default-features = false }
+const_format          = { version = "0.2", default-features = false }
+curve25519-dalek      = { version = "4", default-features = false }
+dashmap               = { version = "6", default-features = false }
+dirs                  = { version = "5", default-features = false }
+futures               = { version = "0.3", default-features = false }
+hex                   = { version = "0.4", default-features = false }
 hex-literal           = { version = "0.4", default-features = false }
-indexmap              = { version = "2.5.0", default-features = false }
+indexmap              = { version = "2", default-features = false }
 monero-serai          = { git = "https://github.com/Cuprate/serai.git", rev = "d5205ce", default-features = false }
-paste                 = { version = "1.0.15", default-features = false }
-pin-project           = { version = "1.1.5", default-features = false }
+paste                 = { version = "1", default-features = false }
+pin-project           = { version = "1", default-features = false }
 randomx-rs            = { git = "https://github.com/Cuprate/randomx-rs.git", rev = "0028464", default-features = false }
-rand                  = { version = "0.8.5", default-features = false }
-rand_distr            = { version = "0.4.3", default-features = false }
-rayon                 = { version = "1.10.0", default-features = false }
-serde_bytes           = { version = "0.11.15", default-features = false }
-serde_json            = { version = "1.0.128", default-features = false }
-serde                 = { version = "1.0.210", default-features = false }
-strum                 = { version = "0.26.3", default-features = false }
-thiserror             = { version = "1.0.63", default-features = false }
-thread_local          = { version = "1.1.8", default-features = false }
-tokio-util            = { version = "0.7.12", default-features = false }
-tokio-stream          = { version = "0.1.16", default-features = false }
-tokio                 = { version = "1.40.0", default-features = false }
+rand                  = { version = "0.8", default-features = false }
+rand_distr            = { version = "0.4", default-features = false }
+rayon                 = { version = "1", default-features = false }
+serde_bytes           = { version = "0.11", default-features = false }
+serde_json            = { version = "1", default-features = false }
+serde                 = { version = "1", default-features = false }
+strum                 = { version = "0.26", default-features = false }
+thiserror             = { version = "1", default-features = false }
+thread_local          = { version = "1", default-features = false }
+tokio-util            = { version = "0.7", default-features = false }
+tokio-stream          = { version = "0.1", default-features = false }
+tokio                 = { version = "1", default-features = false }
 tower                 = { git = "https://github.com/Cuprate/tower.git", rev = "6c7faf0", default-features = false } # <https://github.com/tower-rs/tower/pull/796>
-tracing-subscriber    = { version = "0.3.18", default-features = false }
-tracing               = { version = "0.1.40", default-features = false }
+tracing-subscriber    = { version = "0.3", default-features = false }
+tracing               = { version = "0.1", default-features = false }

 ## workspace.dev-dependencies
 monero-rpc                = { git = "https://github.com/Cuprate/serai.git", rev = "d5205ce" }
 monero-simple-request-rpc = { git = "https://github.com/Cuprate/serai.git", rev = "d5205ce" }
 tempfile                  = { version = "3" }
-pretty_assertions         = { version = "1.4.1" }
+pretty_assertions         = { version = "1" }
 proptest                  = { version = "1" }
-proptest-derive           = { version = "0.4.0" }
-tokio-test                = { version = "0.4.4" }
+proptest-derive           = { version = "0.5" }
+tokio-test                = { version = "0.4" }

 ## TODO:
 ## Potential dependencies.
--- a/binaries/cuprated/Cargo.toml
+++ b/binaries/cuprated/Cargo.toml
@ -13,6 +13,7 @@ cuprate-consensus        = { workspace = true }
 cuprate-fast-sync         = { workspace = true }
 cuprate-consensus-context = { workspace = true }
 cuprate-consensus-rules   = { workspace = true }
+cuprate-constants         = { workspace = true }
 cuprate-cryptonight       = { workspace = true }
 cuprate-helper            = { workspace = true }
 cuprate-epee-encoding     = { workspace = true }
@ -24,7 +25,7 @@ cuprate-p2p-core         = { workspace = true }
 cuprate-dandelion-tower   = { workspace = true, features = ["txpool"] }
 cuprate-async-buffer      = { workspace = true }
 cuprate-address-book      = { workspace = true }
-cuprate-blockchain       = { workspace = true, features = ["service"] }
+cuprate-blockchain        = { workspace = true }
 cuprate-database-service  = { workspace = true }
 cuprate-txpool            = { workspace = true }
 cuprate-database          = { workspace = true }
--- a/binaries/cuprated/src/main.rs
+++ b/binaries/cuprated/src/main.rs
@ -9,6 +9,10 @@
    unused_variables,
    clippy::needless_pass_by_value,
    clippy::unused_async,
+    clippy::diverging_sub_expression,
+    unused_mut,
+    clippy::let_unit_value,
+    clippy::needless_pass_by_ref_mut,
    reason = "TODO: remove after v1.0.0"
 )]

--- a/binaries/cuprated/src/rpc.rs
+++ b/binaries/cuprated/src/rpc.rs
@ -3,6 +3,7 @@
 //! Will contain the code to initiate the RPC and a request handler.

 mod bin;
+mod constants;
 mod handler;
 mod json;
 mod other;
--- a/binaries/cuprated/src/rpc/constants.rs
+++ b/binaries/cuprated/src/rpc/constants.rs
@ -0,0 +1,5 @@
+//! Constants used within RPC.
+
+/// The string message used in RPC response fields for when
+/// `cuprated` does not support a field that `monerod` has.
+pub(super) const FIELD_NOT_SUPPORTED: &str = "`cuprated` does not support this field.";
--- a/binaries/cuprated/src/rpc/handler.rs
+++ b/binaries/cuprated/src/rpc/handler.rs
@ -8,6 +8,8 @@ use monero_serai::block::Block;
 use tower::Service;

 use cuprate_blockchain::service::{BlockchainReadHandle, BlockchainWriteHandle};
+use cuprate_consensus::BlockChainContextService;
+use cuprate_pruning::PruningSeed;
 use cuprate_rpc_interface::RpcHandler;
 use cuprate_rpc_types::{
    bin::{BinRequest, BinResponse},
@ -15,6 +17,7 @@ use cuprate_rpc_types::{
    other::{OtherRequest, OtherResponse},
 };
 use cuprate_txpool::service::{TxpoolReadHandle, TxpoolWriteHandle};
+use cuprate_types::{AddAuxPow, AuxPow, HardFork};

 use crate::rpc::{bin, json, other};

@ -54,6 +57,32 @@ pub enum BlockchainManagerRequest {

    /// The height of the next block in the chain.
    TargetHeight,
+
+    /// Generate new blocks.
+    ///
+    /// This request is only for regtest, see RPC's `generateblocks`.
+    GenerateBlocks {
+        /// Number of the blocks to be generated.
+        amount_of_blocks: u64,
+        /// The previous block's hash.
+        prev_block: [u8; 32],
+        /// The starting value for the nonce.
+        starting_nonce: u32,
+        /// The address that will receive the coinbase reward.
+        wallet_address: String,
+    },
+
+    //    // TODO: the below requests actually belong to the block downloader/syncer:
+    //    // <https://github.com/Cuprate/cuprate/pull/320#discussion_r1811089758>
+    //    /// Get [`Span`] data.
+    //    ///
+    //    /// This is data that describes an active downloading process,
+    //    /// if we are fully synced, this will return an empty [`Vec`].
+    //    Spans,
+
+    //
+    /// Get the next [`PruningSeed`] needed for a pruned sync.
+    NextNeededPruningSeed,
 }

 /// TODO: use real type when public.
@ -69,6 +98,9 @@ pub enum BlockchainManagerResponse {
    /// Response to [`BlockchainManagerRequest::PopBlocks`]
    PopBlocks { new_height: usize },

+    /// Response to [`BlockchainManagerRequest::Prune`]
+    Prune(PruningSeed),
+
    /// Response to [`BlockchainManagerRequest::Pruned`]
    Pruned(bool),

@ -83,6 +115,19 @@ pub enum BlockchainManagerResponse {

    /// Response to [`BlockchainManagerRequest::TargetHeight`]
    TargetHeight { height: usize },
+
+    /// Response to [`BlockchainManagerRequest::GenerateBlocks`]
+    GenerateBlocks {
+        /// Hashes of the blocks generated.
+        blocks: Vec<[u8; 32]>,
+        /// The new top height. (TODO: is this correct?)
+        height: usize,
+    },
+
+    //    /// Response to [`BlockchainManagerRequest::Spans`].
+    //    Spans(Vec<Span<Z::Addr>>),
+    /// Response to [`BlockchainManagerRequest::NextNeededPruningSeed`].
+    NextNeededPruningSeed(PruningSeed),
 }

 /// TODO: use real type when public.
@ -102,6 +147,9 @@ pub struct CupratedRpcHandler {
    /// Read handle to the blockchain database.
    pub blockchain_read: BlockchainReadHandle,

+    /// Handle to the blockchain context service.
+    pub blockchain_context: BlockChainContextService,
+
    /// Handle to the blockchain manager.
    pub blockchain_manager: BlockchainManagerHandle,

@ -117,6 +165,7 @@ impl CupratedRpcHandler {
    pub const fn new(
        restricted: bool,
        blockchain_read: BlockchainReadHandle,
+        blockchain_context: BlockChainContextService,
        blockchain_manager: BlockchainManagerHandle,
        txpool_read: TxpoolReadHandle,
        txpool_manager: std::convert::Infallible,
@ -124,6 +173,7 @@ impl CupratedRpcHandler {
        Self {
            restricted,
            blockchain_read,
+            blockchain_context,
            blockchain_manager,
            txpool_read,
            txpool_manager,
--- a/binaries/cuprated/src/rpc/request/address_book.rs
+++ b/binaries/cuprated/src/rpc/request/address_book.rs
@ -2,26 +2,33 @@

 use std::convert::Infallible;

-use anyhow::Error;
+use anyhow::{anyhow, Error};
 use tower::ServiceExt;

 use cuprate_helper::cast::usize_to_u64;
 use cuprate_p2p_core::{
    services::{AddressBookRequest, AddressBookResponse},
+    types::{BanState, ConnectionId},
    AddressBook, NetworkZone,
 };
+use cuprate_pruning::PruningSeed;
+use cuprate_rpc_types::misc::{ConnectionInfo, Span};
+
+use crate::rpc::constants::FIELD_NOT_SUPPORTED;
+
+// FIXME: use `anyhow::Error` over `tower::BoxError` in address book.

 /// [`AddressBookRequest::PeerlistSize`]
-pub(super) async fn peerlist_size<Z: NetworkZone>(
+pub(crate) async fn peerlist_size<Z: NetworkZone>(
    address_book: &mut impl AddressBook<Z>,
 ) -> Result<(u64, u64), Error> {
    let AddressBookResponse::PeerlistSize { white, grey } = address_book
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(AddressBookRequest::PeerlistSize)
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -29,17 +36,74 @@ pub(super) async fn peerlist_size<Z: NetworkZone>(
    Ok((usize_to_u64(white), usize_to_u64(grey)))
 }

+/// [`AddressBookRequest::ConnectionInfo`]
+pub(crate) async fn connection_info<Z: NetworkZone>(
+    address_book: &mut impl AddressBook<Z>,
+) -> Result<Vec<ConnectionInfo>, Error> {
+    let AddressBookResponse::ConnectionInfo(vec) = address_book
+        .ready()
+        .await
+        .map_err(|e| anyhow!(e))?
+        .call(AddressBookRequest::ConnectionInfo)
+        .await
+        .map_err(|e| anyhow!(e))?
+    else {
+        unreachable!();
+    };
+
+    // FIXME: impl this map somewhere instead of inline.
+    let vec = vec
+        .into_iter()
+        .map(|info| {
+            let (ip, port) = match info.socket_addr {
+                Some(socket) => (socket.ip().to_string(), socket.port().to_string()),
+                None => (String::new(), String::new()),
+            };
+
+            ConnectionInfo {
+                address: info.address.to_string(),
+                address_type: info.address_type,
+                avg_download: info.avg_download,
+                avg_upload: info.avg_upload,
+                connection_id: String::from(ConnectionId::DEFAULT_STR),
+                current_download: info.current_download,
+                current_upload: info.current_upload,
+                height: info.height,
+                host: info.host,
+                incoming: info.incoming,
+                ip,
+                live_time: info.live_time,
+                localhost: info.localhost,
+                local_ip: info.local_ip,
+                peer_id: hex::encode(info.peer_id.to_ne_bytes()),
+                port,
+                pruning_seed: info.pruning_seed.compress(),
+                recv_count: info.recv_count,
+                recv_idle_time: info.recv_idle_time,
+                rpc_credits_per_hash: info.rpc_credits_per_hash,
+                rpc_port: info.rpc_port,
+                send_count: info.send_count,
+                send_idle_time: info.send_idle_time,
+                state: info.state,
+                support_flags: info.support_flags,
+            }
+        })
+        .collect();
+
+    Ok(vec)
+}
+
 /// [`AddressBookRequest::ConnectionCount`]
-pub(super) async fn connection_count<Z: NetworkZone>(
+pub(crate) async fn connection_count<Z: NetworkZone>(
    address_book: &mut impl AddressBook<Z>,
 ) -> Result<(u64, u64), Error> {
    let AddressBookResponse::ConnectionCount { incoming, outgoing } = address_book
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(AddressBookRequest::ConnectionCount)
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -48,17 +112,17 @@ pub(super) async fn connection_count<Z: NetworkZone>(
 }

 /// [`AddressBookRequest::SetBan`]
-pub(super) async fn set_ban<Z: NetworkZone>(
+pub(crate) async fn set_ban<Z: NetworkZone>(
    address_book: &mut impl AddressBook<Z>,
-    peer: cuprate_p2p_core::ban::SetBan<Z::Addr>,
+    set_ban: cuprate_p2p_core::types::SetBan<Z::Addr>,
 ) -> Result<(), Error> {
    let AddressBookResponse::Ok = address_book
        .ready()
        .await
-        .expect("TODO")
-        .call(AddressBookRequest::SetBan(peer))
+        .map_err(|e| anyhow!(e))?
+        .call(AddressBookRequest::SetBan(set_ban))
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -67,17 +131,17 @@ pub(super) async fn set_ban<Z: NetworkZone>(
 }

 /// [`AddressBookRequest::GetBan`]
-pub(super) async fn get_ban<Z: NetworkZone>(
+pub(crate) async fn get_ban<Z: NetworkZone>(
    address_book: &mut impl AddressBook<Z>,
    peer: Z::Addr,
 ) -> Result<Option<std::time::Instant>, Error> {
    let AddressBookResponse::GetBan { unban_instant } = address_book
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(AddressBookRequest::GetBan(peer))
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -86,19 +150,19 @@ pub(super) async fn get_ban<Z: NetworkZone>(
 }

 /// [`AddressBookRequest::GetBans`]
-pub(super) async fn get_bans<Z: NetworkZone>(
+pub(crate) async fn get_bans<Z: NetworkZone>(
    address_book: &mut impl AddressBook<Z>,
-) -> Result<(), Error> {
+) -> Result<Vec<BanState<Z::Addr>>, Error> {
    let AddressBookResponse::GetBans(bans) = address_book
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(AddressBookRequest::GetBans)
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };

-    Ok(todo!())
+    Ok(bans)
 }
--- a/binaries/cuprated/src/rpc/request/blockchain.rs
+++ b/binaries/cuprated/src/rpc/request/blockchain.rs
@ -1,24 +1,61 @@
 //! Functions for [`BlockchainReadRequest`].

 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, HashMap, HashSet},
    ops::Range,
 };

 use anyhow::Error;
-use cuprate_blockchain::service::BlockchainReadHandle;
+use monero_serai::block::Block;
 use tower::{Service, ServiceExt};

+use cuprate_blockchain::{service::BlockchainReadHandle, types::AltChainInfo};
 use cuprate_helper::cast::{u64_to_usize, usize_to_u64};
 use cuprate_types::{
    blockchain::{BlockchainReadRequest, BlockchainResponse},
-    Chain, CoinbaseTxSum, ExtendedBlockHeader, MinerData, OutputHistogramEntry,
-    OutputHistogramInput, OutputOnChain,
+    Chain, ChainInfo, CoinbaseTxSum, ExtendedBlockHeader, HardFork, MinerData,
+    OutputHistogramEntry, OutputHistogramInput, OutputOnChain,
 };

+/// [`BlockchainReadRequest::Block`].
+pub(crate) async fn block(
+    blockchain_read: &mut BlockchainReadHandle,
+    height: u64,
+) -> Result<Block, Error> {
+    let BlockchainResponse::Block(block) = blockchain_read
+        .ready()
+        .await?
+        .call(BlockchainReadRequest::Block {
+            height: u64_to_usize(height),
+        })
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(block)
+}
+
+/// [`BlockchainReadRequest::BlockByHash`].
+pub(crate) async fn block_by_hash(
+    blockchain_read: &mut BlockchainReadHandle,
+    hash: [u8; 32],
+) -> Result<Block, Error> {
+    let BlockchainResponse::Block(block) = blockchain_read
+        .ready()
+        .await?
+        .call(BlockchainReadRequest::BlockByHash(hash))
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(block)
+}
+
 /// [`BlockchainReadRequest::BlockExtendedHeader`].
-pub(super) async fn block_extended_header(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn block_extended_header(
+    blockchain_read: &mut BlockchainReadHandle,
    height: u64,
 ) -> Result<ExtendedBlockHeader, Error> {
    let BlockchainResponse::BlockExtendedHeader(header) = blockchain_read
@ -36,8 +73,8 @@ pub(super) async fn block_extended_header(
 }

 /// [`BlockchainReadRequest::BlockHash`].
-pub(super) async fn block_hash(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn block_hash(
+    blockchain_read: &mut BlockchainReadHandle,
    height: u64,
    chain: Chain,
 ) -> Result<[u8; 32], Error> {
@ -57,8 +94,8 @@ pub(super) async fn block_hash(
 }

 /// [`BlockchainReadRequest::FindBlock`].
-pub(super) async fn find_block(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn find_block(
+    blockchain_read: &mut BlockchainReadHandle,
    block_hash: [u8; 32],
 ) -> Result<Option<(Chain, usize)>, Error> {
    let BlockchainResponse::FindBlock(option) = blockchain_read
@ -74,8 +111,8 @@ pub(super) async fn find_block(
 }

 /// [`BlockchainReadRequest::FilterUnknownHashes`].
-pub(super) async fn filter_unknown_hashes(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn filter_unknown_hashes(
+    blockchain_read: &mut BlockchainReadHandle,
    block_hashes: HashSet<[u8; 32]>,
 ) -> Result<HashSet<[u8; 32]>, Error> {
    let BlockchainResponse::FilterUnknownHashes(output) = blockchain_read
@ -91,8 +128,8 @@ pub(super) async fn filter_unknown_hashes(
 }

 /// [`BlockchainReadRequest::BlockExtendedHeaderInRange`]
-pub(super) async fn block_extended_header_in_range(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn block_extended_header_in_range(
+    blockchain_read: &mut BlockchainReadHandle,
    range: Range<usize>,
    chain: Chain,
 ) -> Result<Vec<ExtendedBlockHeader>, Error> {
@ -111,8 +148,8 @@ pub(super) async fn block_extended_header_in_range(
 }

 /// [`BlockchainReadRequest::ChainHeight`].
-pub(super) async fn chain_height(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn chain_height(
+    blockchain_read: &mut BlockchainReadHandle,
 ) -> Result<(u64, [u8; 32]), Error> {
    let BlockchainResponse::ChainHeight(height, hash) = blockchain_read
        .ready()
@ -127,8 +164,8 @@ pub(super) async fn chain_height(
 }

 /// [`BlockchainReadRequest::GeneratedCoins`].
-pub(super) async fn generated_coins(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn generated_coins(
+    blockchain_read: &mut BlockchainReadHandle,
    block_height: u64,
 ) -> Result<u64, Error> {
    let BlockchainResponse::GeneratedCoins(generated_coins) = blockchain_read
@ -146,8 +183,8 @@ pub(super) async fn generated_coins(
 }

 /// [`BlockchainReadRequest::Outputs`]
-pub(super) async fn outputs(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn outputs(
+    blockchain_read: &mut BlockchainReadHandle,
    outputs: HashMap<u64, HashSet<u64>>,
 ) -> Result<HashMap<u64, HashMap<u64, OutputOnChain>>, Error> {
    let BlockchainResponse::Outputs(outputs) = blockchain_read
@ -163,8 +200,8 @@ pub(super) async fn outputs(
 }

 /// [`BlockchainReadRequest::NumberOutputsWithAmount`]
-pub(super) async fn number_outputs_with_amount(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn number_outputs_with_amount(
+    blockchain_read: &mut BlockchainReadHandle,
    output_amounts: Vec<u64>,
 ) -> Result<HashMap<u64, usize>, Error> {
    let BlockchainResponse::NumberOutputsWithAmount(map) = blockchain_read
@ -182,8 +219,8 @@ pub(super) async fn number_outputs_with_amount(
 }

 /// [`BlockchainReadRequest::KeyImagesSpent`]
-pub(super) async fn key_images_spent(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn key_images_spent(
+    blockchain_read: &mut BlockchainReadHandle,
    key_images: HashSet<[u8; 32]>,
 ) -> Result<bool, Error> {
    let BlockchainResponse::KeyImagesSpent(is_spent) = blockchain_read
@ -199,8 +236,8 @@ pub(super) async fn key_images_spent(
 }

 /// [`BlockchainReadRequest::CompactChainHistory`]
-pub(super) async fn compact_chain_history(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn compact_chain_history(
+    blockchain_read: &mut BlockchainReadHandle,
 ) -> Result<(Vec<[u8; 32]>, u128), Error> {
    let BlockchainResponse::CompactChainHistory {
        block_ids,
@ -218,8 +255,8 @@ pub(super) async fn compact_chain_history(
 }

 /// [`BlockchainReadRequest::FindFirstUnknown`]
-pub(super) async fn find_first_unknown(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn find_first_unknown(
+    blockchain_read: &mut BlockchainReadHandle,
    hashes: Vec<[u8; 32]>,
 ) -> Result<Option<(usize, u64)>, Error> {
    let BlockchainResponse::FindFirstUnknown(resp) = blockchain_read
@ -235,8 +272,8 @@ pub(super) async fn find_first_unknown(
 }

 /// [`BlockchainReadRequest::TotalTxCount`]
-pub(super) async fn total_tx_count(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn total_tx_count(
+    blockchain_read: &mut BlockchainReadHandle,
 ) -> Result<u64, Error> {
    let BlockchainResponse::TotalTxCount(tx_count) = blockchain_read
        .ready()
@ -251,8 +288,8 @@ pub(super) async fn total_tx_count(
 }

 /// [`BlockchainReadRequest::DatabaseSize`]
-pub(super) async fn database_size(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn database_size(
+    blockchain_read: &mut BlockchainReadHandle,
 ) -> Result<(u64, u64), Error> {
    let BlockchainResponse::DatabaseSize {
        database_size,
@ -270,8 +307,8 @@ pub(super) async fn database_size(
 }

 /// [`BlockchainReadRequest::OutputHistogram`]
-pub(super) async fn output_histogram(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn output_histogram(
+    blockchain_read: &mut BlockchainReadHandle,
    input: OutputHistogramInput,
 ) -> Result<Vec<OutputHistogramEntry>, Error> {
    let BlockchainResponse::OutputHistogram(histogram) = blockchain_read
@ -287,8 +324,8 @@ pub(super) async fn output_histogram(
 }

 /// [`BlockchainReadRequest::CoinbaseTxSum`]
-pub(super) async fn coinbase_tx_sum(
-    mut blockchain_read: BlockchainReadHandle,
+pub(crate) async fn coinbase_tx_sum(
+    blockchain_read: &mut BlockchainReadHandle,
    height: u64,
    count: u64,
 ) -> Result<CoinbaseTxSum, Error> {
@ -306,3 +343,35 @@ pub(super) async fn coinbase_tx_sum(

    Ok(sum)
 }
+
+/// [`BlockchainReadRequest::AltChains`]
+pub(crate) async fn alt_chains(
+    blockchain_read: &mut BlockchainReadHandle,
+) -> Result<Vec<ChainInfo>, Error> {
+    let BlockchainResponse::AltChains(vec) = blockchain_read
+        .ready()
+        .await?
+        .call(BlockchainReadRequest::AltChains)
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(vec)
+}
+
+/// [`BlockchainReadRequest::AltChainCount`]
+pub(crate) async fn alt_chain_count(
+    blockchain_read: &mut BlockchainReadHandle,
+) -> Result<u64, Error> {
+    let BlockchainResponse::AltChainCount(count) = blockchain_read
+        .ready()
+        .await?
+        .call(BlockchainReadRequest::AltChainCount)
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(usize_to_u64(count))
+}
--- a/binaries/cuprated/src/rpc/request/blockchain_context.rs
+++ b/binaries/cuprated/src/rpc/request/blockchain_context.rs
@ -2,27 +2,30 @@

 use std::convert::Infallible;

-use anyhow::Error;
+use anyhow::{anyhow, Error};
+use monero_serai::block::Block;
 use tower::{Service, ServiceExt};

 use cuprate_consensus_context::{
    BlockChainContext, BlockChainContextRequest, BlockChainContextResponse,
    BlockChainContextService,
 };
+use cuprate_helper::cast::u64_to_usize;
 use cuprate_types::{FeeEstimate, HardFork, HardForkInfo};

+// FIXME: use `anyhow::Error` over `tower::BoxError` in blockchain context.
+
 /// [`BlockChainContextRequest::Context`].
-pub(super) async fn context(
-    service: &mut BlockChainContextService,
-    height: u64,
+pub(crate) async fn context(
+    blockchain_context: &mut BlockChainContextService,
 ) -> Result<BlockChainContext, Error> {
-    let BlockChainContextResponse::Context(context) = service
+    let BlockChainContextResponse::Context(context) = blockchain_context
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(BlockChainContextRequest::Context)
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -31,17 +34,17 @@ pub(super) async fn context(
 }

 /// [`BlockChainContextRequest::HardForkInfo`].
-pub(super) async fn hard_fork_info(
-    service: &mut BlockChainContextService,
+pub(crate) async fn hard_fork_info(
+    blockchain_context: &mut BlockChainContextService,
    hard_fork: HardFork,
 ) -> Result<HardForkInfo, Error> {
-    let BlockChainContextResponse::HardForkInfo(hf_info) = service
+    let BlockChainContextResponse::HardForkInfo(hf_info) = blockchain_context
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(BlockChainContextRequest::HardForkInfo(hard_fork))
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -50,20 +53,47 @@ pub(super) async fn hard_fork_info(
 }

 /// [`BlockChainContextRequest::FeeEstimate`].
-pub(super) async fn fee_estimate(
-    service: &mut BlockChainContextService,
+pub(crate) async fn fee_estimate(
+    blockchain_context: &mut BlockChainContextService,
    grace_blocks: u64,
 ) -> Result<FeeEstimate, Error> {
-    let BlockChainContextResponse::FeeEstimate(fee) = service
+    let BlockChainContextResponse::FeeEstimate(fee) = blockchain_context
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(BlockChainContextRequest::FeeEstimate { grace_blocks })
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };

    Ok(fee)
 }
+
+/// [`BlockChainContextRequest::CalculatePow`]
+pub(crate) async fn calculate_pow(
+    blockchain_context: &mut BlockChainContextService,
+    hardfork: HardFork,
+    height: u64,
+    block: Box<Block>,
+    seed_hash: [u8; 32],
+) -> Result<[u8; 32], Error> {
+    let BlockChainContextResponse::CalculatePow(hash) = blockchain_context
+        .ready()
+        .await
+        .map_err(|e| anyhow!(e))?
+        .call(BlockChainContextRequest::CalculatePow {
+            hardfork,
+            height: u64_to_usize(height),
+            block,
+            seed_hash,
+        })
+        .await
+        .map_err(|e| anyhow!(e))?
+    else {
+        unreachable!();
+    };
+
+    Ok(hash)
+}
--- a/binaries/cuprated/src/rpc/request/blockchain_manager.rs
+++ b/binaries/cuprated/src/rpc/request/blockchain_manager.rs
@ -5,13 +5,18 @@ use monero_serai::block::Block;
 use tower::{Service, ServiceExt};

 use cuprate_helper::cast::{u64_to_usize, usize_to_u64};
+use cuprate_p2p_core::{types::ConnectionId, NetworkZone};
+use cuprate_pruning::PruningSeed;
+use cuprate_rpc_types::misc::Span;
+use cuprate_types::{AddAuxPow, AuxPow, HardFork};

-use crate::rpc::handler::{
-    BlockchainManagerHandle, BlockchainManagerRequest, BlockchainManagerResponse,
+use crate::rpc::{
+    constants::FIELD_NOT_SUPPORTED,
+    handler::{BlockchainManagerHandle, BlockchainManagerRequest, BlockchainManagerResponse},
 };

 /// [`BlockchainManagerRequest::PopBlocks`]
-pub(super) async fn pop_blocks(
+pub(crate) async fn pop_blocks(
    blockchain_manager: &mut BlockchainManagerHandle,
    amount: u64,
 ) -> Result<u64, Error> {
@ -30,8 +35,10 @@ pub(super) async fn pop_blocks(
 }

 /// [`BlockchainManagerRequest::Prune`]
-pub(super) async fn prune(blockchain_manager: &mut BlockchainManagerHandle) -> Result<(), Error> {
-    let BlockchainManagerResponse::Ok = blockchain_manager
+pub(crate) async fn prune(
+    blockchain_manager: &mut BlockchainManagerHandle,
+) -> Result<PruningSeed, Error> {
+    let BlockchainManagerResponse::Prune(seed) = blockchain_manager
        .ready()
        .await?
        .call(BlockchainManagerRequest::Prune)
@ -40,11 +47,11 @@ pub(super) async fn prune(blockchain_manager: &mut BlockchainManagerHandle) -> R
        unreachable!();
    };

-    Ok(())
+    Ok(seed)
 }

 /// [`BlockchainManagerRequest::Pruned`]
-pub(super) async fn pruned(
+pub(crate) async fn pruned(
    blockchain_manager: &mut BlockchainManagerHandle,
 ) -> Result<bool, Error> {
    let BlockchainManagerResponse::Pruned(pruned) = blockchain_manager
@ -60,7 +67,7 @@ pub(super) async fn pruned(
 }

 /// [`BlockchainManagerRequest::RelayBlock`]
-pub(super) async fn relay_block(
+pub(crate) async fn relay_block(
    blockchain_manager: &mut BlockchainManagerHandle,
    block: Block,
 ) -> Result<(), Error> {
@ -77,7 +84,7 @@ pub(super) async fn relay_block(
 }

 /// [`BlockchainManagerRequest::Syncing`]
-pub(super) async fn syncing(
+pub(crate) async fn syncing(
    blockchain_manager: &mut BlockchainManagerHandle,
 ) -> Result<bool, Error> {
    let BlockchainManagerResponse::Syncing(syncing) = blockchain_manager
@ -93,7 +100,7 @@ pub(super) async fn syncing(
 }

 /// [`BlockchainManagerRequest::Synced`]
-pub(super) async fn synced(
+pub(crate) async fn synced(
    blockchain_manager: &mut BlockchainManagerHandle,
 ) -> Result<bool, Error> {
    let BlockchainManagerResponse::Synced(syncing) = blockchain_manager
@ -109,7 +116,7 @@ pub(super) async fn synced(
 }

 /// [`BlockchainManagerRequest::Target`]
-pub(super) async fn target(
+pub(crate) async fn target(
    blockchain_manager: &mut BlockchainManagerHandle,
 ) -> Result<std::time::Duration, Error> {
    let BlockchainManagerResponse::Target(target) = blockchain_manager
@ -125,7 +132,7 @@ pub(super) async fn target(
 }

 /// [`BlockchainManagerRequest::TargetHeight`]
-pub(super) async fn target_height(
+pub(crate) async fn target_height(
    blockchain_manager: &mut BlockchainManagerHandle,
 ) -> Result<u64, Error> {
    let BlockchainManagerResponse::TargetHeight { height } = blockchain_manager
@ -139,3 +146,76 @@ pub(super) async fn target_height(

    Ok(usize_to_u64(height))
 }
+
+/// [`BlockchainManagerRequest::GenerateBlocks`]
+pub(crate) async fn generate_blocks(
+    blockchain_manager: &mut BlockchainManagerHandle,
+    amount_of_blocks: u64,
+    prev_block: [u8; 32],
+    starting_nonce: u32,
+    wallet_address: String,
+) -> Result<(Vec<[u8; 32]>, u64), Error> {
+    let BlockchainManagerResponse::GenerateBlocks { blocks, height } = blockchain_manager
+        .ready()
+        .await?
+        .call(BlockchainManagerRequest::GenerateBlocks {
+            amount_of_blocks,
+            prev_block,
+            starting_nonce,
+            wallet_address,
+        })
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok((blocks, usize_to_u64(height)))
+}
+
+// [`BlockchainManagerRequest::Spans`]
+pub(crate) async fn spans<Z: NetworkZone>(
+    blockchain_manager: &mut BlockchainManagerHandle,
+) -> Result<Vec<Span>, Error> {
+    // let BlockchainManagerResponse::Spans(vec) = blockchain_manager
+    //     .ready()
+    //     .await?
+    //     .call(BlockchainManagerRequest::Spans)
+    //     .await?
+    // else {
+    //     unreachable!();
+    // };
+
+    let vec: Vec<cuprate_p2p_core::types::Span<Z::Addr>> = todo!();
+
+    // FIXME: impl this map somewhere instead of inline.
+    let vec = vec
+        .into_iter()
+        .map(|span| Span {
+            connection_id: String::from(ConnectionId::DEFAULT_STR),
+            nblocks: span.nblocks,
+            rate: span.rate,
+            remote_address: span.remote_address.to_string(),
+            size: span.size,
+            speed: span.speed,
+            start_block_height: span.start_block_height,
+        })
+        .collect();
+
+    Ok(vec)
+}
+
+/// [`BlockchainManagerRequest::NextNeededPruningSeed`]
+pub(crate) async fn next_needed_pruning_seed(
+    blockchain_manager: &mut BlockchainManagerHandle,
+) -> Result<PruningSeed, Error> {
+    let BlockchainManagerResponse::NextNeededPruningSeed(seed) = blockchain_manager
+        .ready()
+        .await?
+        .call(BlockchainManagerRequest::NextNeededPruningSeed)
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(seed)
+}
--- a/binaries/cuprated/src/rpc/request/txpool.rs
+++ b/binaries/cuprated/src/rpc/request/txpool.rs
@ -2,7 +2,7 @@

 use std::convert::Infallible;

-use anyhow::Error;
+use anyhow::{anyhow, Error};
 use tower::{Service, ServiceExt};

 use cuprate_helper::cast::usize_to_u64;
@ -14,15 +14,17 @@ use cuprate_txpool::{
    TxEntry,
 };

+// FIXME: use `anyhow::Error` over `tower::BoxError` in txpool.
+
 /// [`TxpoolReadRequest::Backlog`]
-pub(super) async fn backlog(txpool_read: &mut TxpoolReadHandle) -> Result<Vec<TxEntry>, Error> {
+pub(crate) async fn backlog(txpool_read: &mut TxpoolReadHandle) -> Result<Vec<TxEntry>, Error> {
    let TxpoolReadResponse::Backlog(tx_entries) = txpool_read
        .ready()
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
        .call(TxpoolReadRequest::Backlog)
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -31,14 +33,19 @@ pub(super) async fn backlog(txpool_read: &mut TxpoolReadHandle) -> Result<Vec<Tx
 }

 /// [`TxpoolReadRequest::Size`]
-pub(super) async fn size(txpool_read: &mut TxpoolReadHandle) -> Result<u64, Error> {
+pub(crate) async fn size(
+    txpool_read: &mut TxpoolReadHandle,
+    include_sensitive_txs: bool,
+) -> Result<u64, Error> {
    let TxpoolReadResponse::Size(size) = txpool_read
        .ready()
        .await
-        .expect("TODO")
-        .call(TxpoolReadRequest::Size)
+        .map_err(|e| anyhow!(e))?
+        .call(TxpoolReadRequest::Size {
+            include_sensitive_txs,
+        })
        .await
-        .expect("TODO")
+        .map_err(|e| anyhow!(e))?
    else {
        unreachable!();
    };
@ -47,9 +54,17 @@ pub(super) async fn size(txpool_read: &mut TxpoolReadHandle) -> Result<u64, Erro
 }

 /// TODO
-#[expect(clippy::needless_pass_by_ref_mut, reason = "TODO: remove after impl")]
-pub(super) async fn flush(
-    txpool_read: &mut TxpoolReadHandle,
+pub(crate) async fn flush(
+    txpool_manager: &mut Infallible,
+    tx_hashes: Vec<[u8; 32]>,
+) -> Result<(), Error> {
+    todo!();
+    Ok(())
+}
+
+/// TODO
+pub(crate) async fn relay(
+    txpool_manager: &mut Infallible,
    tx_hashes: Vec<[u8; 32]>,
 ) -> Result<(), Error> {
    todo!();
--- a/books/architecture/src/appendix/crates.md
+++ b/books/architecture/src/appendix/crates.md
@ -35,6 +35,7 @@ cargo doc --open --package cuprate-blockchain
 | [`cuprate-async-buffer`](https://doc.cuprate.org/cuprate_async_buffer) | [`p2p/async-buffer/`](https://github.com/Cuprate/cuprate/tree/main/p2p/async-buffer) | A bounded SPSC, FIFO, asynchronous buffer that supports arbitrary weights for values
 | [`cuprate-dandelion-tower`](https://doc.cuprate.org/cuprate_dandelion_tower) | [`p2p/dandelion-tower/`](https://github.com/Cuprate/cuprate/tree/main/p2p/dandelion-tower) | TODO
 | [`cuprate-p2p`](https://doc.cuprate.org/cuprate_p2p) | [`p2p/p2p/`](https://github.com/Cuprate/cuprate/tree/main/p2p/p2p) | TODO
+| [`cuprate-p2p-bucket`](https://doc.cuprate.org/cuprate_p2p_bucket) | [`p2p/bucket/`](https://github.com/Cuprate/cuprate/tree/main/p2p/bucket) | A collection data structure discriminating its items into "buckets" of limited size.
 | [`cuprate-p2p-core`](https://doc.cuprate.org/cuprate_p2p_core) | [`p2p/p2p-core/`](https://github.com/Cuprate/cuprate/tree/main/p2p/p2p-core) | TODO

 ## Storage
--- a/consensus/Cargo.toml
+++ b/consensus/Cargo.toml
@ -27,17 +27,5 @@ thread_local = { workspace = true }
 hex = { workspace = true }
 rand = { workspace = true }

-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-cuprate-consensus-rules =  { workspace = true, features = ["proptest"]}
-
-hex-literal = { workspace = true }
-curve25519-dalek = { workspace = true }
-
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"]}
-tokio-test = { workspace = true }
-proptest = { workspace = true }
-proptest-derive = { workspace = true }
-
 [lints]
 workspace = true
--- a/consensus/context/src/lib.rs
+++ b/consensus/context/src/lib.rs
@ -18,6 +18,7 @@ use std::{
 };

 use futures::{channel::oneshot, FutureExt};
+use monero_serai::block::Block;
 use tokio::sync::mpsc;
 use tokio_util::sync::PollSender;
 use tower::Service;
@ -267,6 +268,21 @@ pub enum BlockChainContextRequest {
        grace_blocks: u64,
    },

+    /// Calculate proof-of-work for this block.
+    CalculatePow {
+        /// The hardfork of the protocol at this block height.
+        hardfork: HardFork,
+        /// The height of the block.
+        height: usize,
+        /// The block data.
+        ///
+        /// This is boxed because [`Block`] causes this enum to be 1200 bytes,
+        /// where the 2nd variant is only 96 bytes.
+        block: Box<Block>,
+        /// The seed hash for the proof-of-work.
+        seed_hash: [u8; 32],
+    },
+
    /// Clear the alt chain context caches.
    ClearAltCache,

@ -364,6 +380,9 @@ pub enum BlockChainContextResponse {
    /// Response to [`BlockChainContextRequest::FeeEstimate`]
    FeeEstimate(FeeEstimate),

+    /// Response to [`BlockChainContextRequest::CalculatePow`]
+    CalculatePow([u8; 32]),
+
    /// Response to [`BlockChainContextRequest::AltChains`]
    ///
    /// If the inner [`Vec::is_empty`], there were no alternate chains.
--- a/consensus/context/src/task.rs
+++ b/consensus/context/src/task.rs
@ -324,7 +324,8 @@ impl<D: Database + Clone + Send + 'static> ContextTask<D> {
            }
            BlockChainContextRequest::HardForkInfo(_)
            | BlockChainContextRequest::FeeEstimate { .. }
-            | BlockChainContextRequest::AltChains => {
+            | BlockChainContextRequest::AltChains
+            | BlockChainContextRequest::CalculatePow { .. } => {
                todo!("finish https://github.com/Cuprate/cuprate/pull/297")
            }
        })
--- a/consensus/fast-sync/Cargo.toml
+++ b/consensus/fast-sync/Cargo.toml
@ -25,7 +25,5 @@ thiserror    = { workspace = true }
 tokio        = { workspace = true, features = ["full"] }
 tower        = { workspace = true }

-[dev-dependencies]
-
 [lints]
 workspace = true
--- a/consensus/rules/Cargo.toml
+++ b/consensus/rules/Cargo.toml
@ -31,10 +31,5 @@ thiserror = { workspace = true }

 rayon = { workspace = true, optional = true }

-[dev-dependencies]
-proptest = { workspace = true }
-proptest-derive = { workspace = true }
-tokio = { version = "1.35.0", features = ["rt-multi-thread", "macros"] }
-
 [lints]
 workspace = true
--- a/consensus/src/tests/mock_db.rs
+++ b/consensus/src/tests/mock_db.rs
@ -1,5 +1,3 @@
-#![expect(non_local_definitions, reason = "proptest macro")]
-
 use std::{
    future::Future,
    pin::Pin,
--- a/constants/Cargo.toml
+++ b/constants/Cargo.toml
@ -16,7 +16,5 @@ rpc     = []

 [dependencies]

-[dev-dependencies]
-
 [lints]
 workspace = true
--- a/cryptonight/Cargo.toml
+++ b/cryptonight/Cargo.toml
@ -17,8 +17,5 @@ keccak = "0.1.5"
 digest = "0.10.7"
 seq-macro = "0.3.5"

-[dev-dependencies]
-hex = { workspace = true, features = ["std"] }
-
 [lints]
 workspace = true
--- a/deny.toml
+++ b/deny.toml
@ -81,6 +81,9 @@ ignore = [
    #{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
    #"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
    #{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
+
+    # TODO: check this is sorted before a beta release.
+    { id = "RUSTSEC-2024-0370", reason = "unmaintained crate, not necessarily vulnerable yet." }
 ]
 # If this is true, then cargo deny will use the git executable to fetch advisory database.
 # If this is false, then it uses a built-in git library.
@ -110,6 +113,7 @@ allow = [
    "Apache-2.0",                     # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
    "MPL-2.0",                        # https://www.mozilla.org/en-US/MPL/2.0/FAQ/
    "BSL-1.0",                        # https://tldrlegal.com/license/boost-software-license-1.0-explained
+    "Zlib",                           # https://spdx.org/licenses/Zlib.html

    # OpenSSL 3.0+ uses Apache-2.0
    # OpenSSL 1.x.x uses https://www.openssl.org/source/license-openssl-ssleay.txt
--- a/helper/Cargo.toml
+++ b/helper/Cargo.toml
@ -17,7 +17,7 @@ asynch    = ["dep:futures", "dep:rayon"]
 cast      = []
 constants = []
 crypto    = ["dep:curve25519-dalek", "dep:monero-serai", "std"]
-fs        = ["dep:dirs"]
+fs        = ["dep:dirs", "std"]
 num       = []
 map       = ["cast", "dep:monero-serai", "dep:cuprate-constants"]
 time      = ["dep:chrono", "std"]
@ -43,9 +43,5 @@ target_os_lib = { package = "windows", version = ">=0.51", features = ["Win32_Sy
 [target.'cfg(unix)'.dependencies]
 target_os_lib = { package = "libc", version = "0.2.158", optional = true }

-[dev-dependencies]
-tokio            = { workspace = true, features = ["full"] }
-curve25519-dalek = { workspace = true }
-
 [lints]
 workspace = true
--- a/helper/src/cast.rs
+++ b/helper/src/cast.rs
@ -18,7 +18,6 @@
 //                                                                              //
 //============================ SAFETY: DO NOT REMOVE ===========================//

-//---------------------------------------------------------------------------------------------------- Free functions
 /// Cast [`u64`] to [`usize`].
 #[inline(always)]
 pub const fn u64_to_usize(u: u64) -> usize {
--- a/helper/src/lib.rs
+++ b/helper/src/lib.rs
@ -11,7 +11,7 @@ pub mod atomic;
 #[cfg(feature = "cast")]
 pub mod cast;

-#[cfg(feature = "fs")]
+#[cfg(all(feature = "fs", feature = "std"))]
 pub mod fs;

 pub mod network;
--- a/net/epee-encoding/Cargo.toml
+++ b/net/epee-encoding/Cargo.toml
@ -23,8 +23,5 @@ ref-cast = "1.0.23"
 bytes = { workspace = true }
 thiserror = { workspace = true, optional = true}

-[dev-dependencies]
-hex = { workspace = true, features = ["default"] }
-
 [lints]
 workspace = true
--- a/net/epee-encoding/src/container_as_blob.rs
+++ b/net/epee-encoding/src/container_as_blob.rs
@ -1,3 +1,5 @@
+use alloc::{string::ToString, vec, vec::Vec};
+
 use bytes::{Buf, BufMut, Bytes, BytesMut};
 use ref_cast::RefCast;

--- a/net/epee-encoding/src/error.rs
+++ b/net/epee-encoding/src/error.rs
@ -1,3 +1,4 @@
+use alloc::string::{String, ToString};
 use core::{
    fmt::{Debug, Formatter},
    num::TryFromIntError,
--- a/net/epee-encoding/src/lib.rs
+++ b/net/epee-encoding/src/lib.rs
@ -64,6 +64,7 @@ use hex as _;

 extern crate alloc;

+use alloc::string::ToString;
 use core::str::from_utf8 as str_from_utf8;

 use bytes::{Buf, BufMut, Bytes, BytesMut};
--- a/net/epee-encoding/src/value.rs
+++ b/net/epee-encoding/src/value.rs
@ -1,7 +1,7 @@
 //! This module contains a [`EpeeValue`] trait and
 //! impls for some possible base epee values.

-use alloc::{string::String, vec::Vec};
+use alloc::{string::String, vec, vec::Vec};
 use core::fmt::Debug;

 use bytes::{Buf, BufMut, Bytes, BytesMut};
--- a/net/fixed-bytes/Cargo.toml
+++ b/net/fixed-bytes/Cargo.toml
@ -15,8 +15,5 @@ thiserror = { workspace = true, optional = true }
 bytes = { workspace = true }
 serde = { workspace = true, features = ["derive"], optional = true }

-[dev-dependencies]
-serde_json = { workspace = true, features = ["std"] }
-
 [lints]
 workspace = true
--- a/net/levin/Cargo.toml
+++ b/net/levin/Cargo.toml
@ -22,12 +22,5 @@ tokio-util = { workspace = true, features = ["codec"]}

 tracing = { workspace = true, features = ["std"], optional = true }

-[dev-dependencies]
-proptest = { workspace = true }
-rand = { workspace = true, features = ["std", "std_rng"] }
-tokio-util = { workspace = true, features = ["io-util"]}
-tokio = { workspace = true, features = ["full"] }
-futures = { workspace = true, features = ["std"] }
-
 [lints]
 workspace = true
--- a/net/wire/Cargo.toml
+++ b/net/wire/Cargo.toml
@ -21,8 +21,5 @@ bitflags = { workspace = true, features = ["std"] }
 bytes = { workspace = true, features = ["std"] }
 thiserror = { workspace = true }

-[dev-dependencies]
-hex = { workspace = true, features = ["std"]}
-
 [lints]
 workspace = true
--- a/p2p/address-book/Cargo.toml
+++ b/p2p/address-book/Cargo.toml
@ -9,7 +9,7 @@ authors = ["Boog900"]
 [dependencies]
 cuprate-constants   = { workspace = true }
 cuprate-pruning     = { workspace = true }
-cuprate-p2p-core    = { workspace = true }
+cuprate-p2p-core    = { workspace = true, features = ["borsh"] }

 tower = { workspace = true, features = ["util"] }
 tokio = { workspace = true, features = ["time", "fs", "rt"]}
@ -25,10 +25,5 @@ rand = { workspace = true, features = ["std", "std_rng"] }

 borsh = { workspace = true, features = ["derive", "std"]}

-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"]}
-
 [lints]
 workspace = true
--- a/p2p/address-book/src/book.rs
+++ b/p2p/address-book/src/book.rs
@ -423,7 +423,8 @@ impl<Z: BorshNetworkZone> Service<AddressBookRequest<Z>> for AddressBook<Z> {
            AddressBookRequest::PeerlistSize
            | AddressBookRequest::ConnectionCount
            | AddressBookRequest::SetBan(_)
-            | AddressBookRequest::GetBans => {
+            | AddressBookRequest::GetBans
+            | AddressBookRequest::ConnectionInfo => {
                todo!("finish https://github.com/Cuprate/cuprate/pull/297")
            }
        };
--- a/p2p/async-buffer/Cargo.toml
+++ b/p2p/async-buffer/Cargo.toml
@ -9,6 +9,3 @@ authors = ["Boog900"]
 thiserror = { workspace = true }
 futures = { workspace = true, features = ["std"] }
 pin-project = { workspace = true }
-
-[dev-dependencies]
-tokio = { workspace = true, features = ["full"] }
--- a/p2p/bucket/Cargo.toml
+++ b/p2p/bucket/Cargo.toml
@ -0,0 +1,13 @@
+[package]
+name = "cuprate-p2p-bucket"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+authors = ["SyntheticBird"]
+
+[dependencies]
+arrayvec = { workspace = true }
+rand     = { workspace = true, features = ["std", "std_rng"]}
+
+[lints]
+workspace = true
--- a/p2p/bucket/src/lib.rs
+++ b/p2p/bucket/src/lib.rs
@ -0,0 +1,172 @@
+//! Bucket data structure
+//!
+//! A collection data structure that discriminates its unique items and place them into "buckets".
+//!
+//! The item must implement the [`Bucketable`] trait that defines how to create the discriminant
+//! from the item type. The data structure will internally contain any item into "buckets" or vectors
+//! of sized capacity `N` that regroup all the stored items with this specific discriminant.
+//!
+//! A practical example of this data structure is for storing `N` amount of IP discriminated by their subnets.
+//! You can store in each "buckets" corresponding to a `/16` subnet up to `N` IPs of that subnet.
+//!
+//! # Example
+//!
+//! ```
+//! use cuprate_p2p_bucket::Bucket;
+//! use std::net::Ipv4Addr;
+//!
+//! // Create a new bucket that can store at most 2 IPs in a particular `/16` subnet.
+//! let mut bucket = Bucket::<2,Ipv4Addr>::new();
+//!
+//! // Fulfill the `96.96.0.0/16` bucket.
+//! bucket.push("96.96.0.1".parse().unwrap());
+//! bucket.push("96.96.0.2".parse().unwrap());
+//! assert_eq!(2, bucket.len());
+//! assert_eq!(2, bucket.len_bucket(&[96_u8,96_u8]).unwrap());
+//!
+//! // Push a new IP from another subnet
+//! bucket.push("127.0.0.1".parse().unwrap());
+//! assert_eq!(3, bucket.len());
+//! assert_eq!(2, bucket.len_bucket(&[96_u8,96_u8]).unwrap());
+//! assert_eq!(1, bucket.len_bucket(&[127_u8,0_u8]).unwrap());
+//!
+//! // Attempting to push a new IP within `96.96.0.0/16` bucket will return the IP back
+//! // as this subnet is already full.
+//! let pushed = bucket.push("96.96.0.3".parse().unwrap());
+//! assert!(pushed.is_some());
+//! assert_eq!(2, bucket.len_bucket(&[96_u8,96_u8]).unwrap());
+//!
+//! ```
+
+use arrayvec::{ArrayVec, CapacityError};
+use rand::random;
+
+use std::{collections::BTreeMap, net::Ipv4Addr};
+
+/// A discriminant that can be computed from the type.
+pub trait Bucketable: Sized + Eq + Clone {
+    /// The type of the discriminant being used in the Binary tree.
+    type Discriminant: Ord + AsRef<[u8]>;
+
+    /// Method that can compute the discriminant from the item.
+    fn discriminant(&self) -> Self::Discriminant;
+}
+
+/// A collection data structure discriminating its unique items
+/// with a specified method. Limiting the amount of items stored
+/// with that discriminant to the const `N`.
+pub struct Bucket<const N: usize, I: Bucketable> {
+    /// The storage of the bucket
+    storage: BTreeMap<I::Discriminant, ArrayVec<I, N>>,
+}
+
+impl<const N: usize, I: Bucketable> Bucket<N, I> {
+    /// Create a new Bucket
+    pub const fn new() -> Self {
+        Self {
+            storage: BTreeMap::new(),
+        }
+    }
+
+    /// Push a new element into the Bucket
+    ///
+    /// Will internally create a new vector for each new discriminant being
+    /// generated from an item.
+    ///
+    /// This function WILL NOT push the element if it already exists.
+    ///
+    /// Return `None` if the item has been pushed or ignored. `Some(I)` if
+    /// the vector is full.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cuprate_p2p_bucket::Bucket;
+    /// use std::net::Ipv4Addr;
+    ///
+    /// let mut bucket = Bucket::<8,Ipv4Addr>::new();
+    ///
+    /// // Push a first IP address.
+    /// bucket.push("127.0.0.1".parse().unwrap());
+    /// assert_eq!(1, bucket.len());
+    ///
+    /// // Push the same IP address a second time.
+    /// bucket.push("127.0.0.1".parse().unwrap());
+    /// assert_eq!(1, bucket.len());
+    /// ```
+    pub fn push(&mut self, item: I) -> Option<I> {
+        let discriminant = item.discriminant();
+
+        if let Some(vec) = self.storage.get_mut(&discriminant) {
+            // Push the item if it doesn't exist.
+            if !vec.contains(&item) {
+                return vec.try_push(item).err().map(CapacityError::element);
+            }
+        } else {
+            // Initialize the vector if not found.
+            let mut vec = ArrayVec::<I, N>::new();
+            vec.push(item);
+            self.storage.insert(discriminant, vec);
+        }
+
+        None
+    }
+
+    /// Will attempt to remove an item from the bucket.
+    pub fn remove(&mut self, item: &I) -> Option<I> {
+        self.storage.get_mut(&item.discriminant()).and_then(|vec| {
+            vec.iter()
+                .enumerate()
+                .find_map(|(i, v)| (item == v).then_some(i))
+                .map(|index| vec.swap_remove(index))
+        })
+    }
+
+    /// Return the number of item stored within the storage
+    pub fn len(&self) -> usize {
+        self.storage.values().map(ArrayVec::len).sum()
+    }
+
+    /// Return the number of item stored with a specific discriminant.
+    ///
+    /// This method returns None if the bucket with this discriminant
+    /// doesn't exist.
+    pub fn len_bucket(&self, discriminant: &I::Discriminant) -> Option<usize> {
+        self.storage.get(discriminant).map(ArrayVec::len)
+    }
+
+    /// Return `true` if the storage contains no items
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Return a reference to an item chosen at random.
+    ///
+    /// Repeated use of this function will provide a normal distribution of
+    /// items based on their discriminants.
+    pub fn get_random(&mut self) -> Option<&I> {
+        // Get the total amount of discriminants to explore.
+        let len = self.storage.len();
+
+        // Get a random bucket.
+        let (_, vec) = self.storage.iter().nth(random::<usize>() / len).unwrap();
+
+        // Return a reference chose at random.
+        vec.get(random::<usize>() / vec.len())
+    }
+}
+
+impl<const N: usize, I: Bucketable> Default for Bucket<N, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Bucketable for Ipv4Addr {
+    /// We are discriminating by `/16` subnets.
+    type Discriminant = [u8; 2];
+
+    fn discriminant(&self) -> Self::Discriminant {
+        [self.octets()[0], self.octets()[1]]
+    }
+}
--- a/p2p/dandelion-tower/Cargo.toml
+++ b/p2p/dandelion-tower/Cargo.toml
@ -22,9 +22,5 @@ rand_distr = { workspace = true, features = ["std"], optional = true }

 thiserror = { workspace = true }

-[dev-dependencies]
-tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync"] }
-proptest = { workspace = true, features = ["default"] }
-
 [lints]
 workspace = true
--- a/p2p/p2p-core/Cargo.toml
+++ b/p2p/p2p-core/Cargo.toml
@ -13,6 +13,7 @@ borsh = ["dep:borsh", "cuprate-pruning/borsh"]
 cuprate-helper  = { workspace = true, features = ["asynch"], default-features = false }
 cuprate-wire    = { workspace = true, features = ["tracing"] }
 cuprate-pruning = { workspace = true }
+cuprate-types   = { workspace = true }

 tokio = { workspace = true, features = ["net", "sync", "macros", "time", "rt", "rt-multi-thread"]}
 tokio-util = { workspace = true, features = ["codec"] }
@ -28,11 +29,5 @@ hex-literal = { workspace = true }

 borsh = { workspace = true, features = ["derive", "std"], optional = true }

-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-
-hex = { workspace = true, features = ["std"] }
-tokio-test = { workspace = true }
-
 [lints]
 workspace = true
--- a/p2p/p2p-core/src/ban.rs
+++ b/p2p/p2p-core/src/ban.rs
@ -1,23 +0,0 @@
-//! Data structures related to bans.
-
-use std::time::{Duration, Instant};
-
-use crate::NetZoneAddress;
-
-/// Data within [`crate::services::AddressBookRequest::SetBan`].
-pub struct SetBan<A: NetZoneAddress> {
-    /// Address of the peer.
-    pub address: A,
-    /// - If [`Some`], how long this peer should be banned for
-    /// - If [`None`], the peer will be unbanned
-    pub ban: Option<Duration>,
-}
-
-/// Data within [`crate::services::AddressBookResponse::GetBans`].
-pub struct BanState<A: NetZoneAddress> {
-    /// Address of the peer.
-    pub address: A,
-    /// - If [`Some`], the peer is banned until this [`Instant`]
-    /// - If [`None`], the peer is not currently banned
-    pub unban_instant: Option<Instant>,
-}
--- a/p2p/p2p-core/src/client/handshaker/builder/dummy.rs
+++ b/p2p/p2p-core/src/client/handshaker/builder/dummy.rs
@ -111,7 +111,8 @@ impl<N: NetworkZone> Service<AddressBookRequest<N>> for DummyAddressBook {
            AddressBookRequest::PeerlistSize
            | AddressBookRequest::ConnectionCount
            | AddressBookRequest::SetBan(_)
-            | AddressBookRequest::GetBans => {
+            | AddressBookRequest::GetBans
+            | AddressBookRequest::ConnectionInfo => {
                todo!("finish https://github.com/Cuprate/cuprate/pull/297")
            }
        }))
--- a/p2p/p2p-core/src/lib.rs
+++ b/p2p/p2p-core/src/lib.rs
@ -75,7 +75,6 @@ use cuprate_wire::{
    NetworkAddress,
 };

-pub mod ban;
 pub mod client;
 mod constants;
 pub mod error;
@ -83,6 +82,7 @@ pub mod handles;
 mod network_zones;
 pub mod protocol;
 pub mod services;
+pub mod types;

 pub use error::*;
 pub use network_zones::{ClearNet, ClearNetServerCfg};
--- a/p2p/p2p-core/src/services.rs
+++ b/p2p/p2p-core/src/services.rs
@ -4,9 +4,9 @@ use cuprate_pruning::{PruningError, PruningSeed};
 use cuprate_wire::{CoreSyncData, PeerListEntryBase};

 use crate::{
-    ban::{BanState, SetBan},
    client::InternalPeerID,
    handles::ConnectionHandle,
+    types::{BanState, ConnectionInfo, SetBan},
    NetZoneAddress, NetworkAddressIncorrectZone, NetworkZone,
 };

@ -118,6 +118,9 @@ pub enum AddressBookRequest<Z: NetworkZone> {
    /// Get the amount of white & grey peers.
    PeerlistSize,

+    /// Get information on all connections.
+    ConnectionInfo,
+
    /// Get the amount of incoming & outgoing connections.
    ConnectionCount,

@ -152,6 +155,9 @@ pub enum AddressBookResponse<Z: NetworkZone> {
    /// Response to [`AddressBookRequest::PeerlistSize`].
    PeerlistSize { white: usize, grey: usize },

+    /// Response to [`AddressBookRequest::ConnectionInfo`].
+    ConnectionInfo(Vec<ConnectionInfo<Z::Addr>>),
+
    /// Response to [`AddressBookRequest::ConnectionCount`].
    ConnectionCount { incoming: usize, outgoing: usize },

--- a/p2p/p2p-core/src/types.rs
+++ b/p2p/p2p-core/src/types.rs
@ -0,0 +1,96 @@
+//! General data structures.
+
+use std::time::{Duration, Instant};
+
+use cuprate_pruning::PruningSeed;
+use cuprate_types::{AddressType, ConnectionState};
+
+use crate::NetZoneAddress;
+
+/// Data within [`crate::services::AddressBookRequest::SetBan`].
+pub struct SetBan<A: NetZoneAddress> {
+    /// Address of the peer.
+    pub address: A,
+    /// - If [`Some`], how long this peer should be banned for
+    /// - If [`None`], the peer will be unbanned
+    pub ban: Option<Duration>,
+}
+
+/// Data within [`crate::services::AddressBookResponse::GetBans`].
+pub struct BanState<A: NetZoneAddress> {
+    /// Address of the peer.
+    pub address: A,
+    /// - If [`Some`], the peer is banned until this [`Instant`]
+    /// - If [`None`], the peer is not currently banned
+    pub unban_instant: Option<Instant>,
+}
+
+/// Data within [`crate::services::AddressBookResponse::ConnectionInfo`].
+pub struct ConnectionInfo<A: NetZoneAddress> {
+    // The following fields are mostly the same as `monerod`.
+    pub address: A,
+    pub address_type: AddressType,
+    pub avg_download: u64,
+    pub avg_upload: u64,
+    pub current_download: u64,
+    pub current_upload: u64,
+    pub height: u64,
+    /// Either a domain or an IP without the port.
+    pub host: String,
+    pub incoming: bool,
+    pub live_time: u64,
+    pub localhost: bool,
+    pub local_ip: bool,
+    pub peer_id: u64,
+    pub pruning_seed: PruningSeed,
+    pub recv_count: u64,
+    pub recv_idle_time: u64,
+    pub rpc_credits_per_hash: u32,
+    pub rpc_port: u16,
+    pub send_count: u64,
+    pub send_idle_time: u64,
+    pub state: ConnectionState,
+    pub support_flags: u32,
+
+    // The following fields are slightly different than `monerod`.
+
+    //
+    /// [`None`] if Tor/i2p or unknown.
+    pub socket_addr: Option<std::net::SocketAddr>,
+
+    /// This field does not exist for `cuprated`'s RPC, this is just a marker type:
+    /// - <https://github.com/Cuprate/cuprate/pull/320#discussion_r1811335020>
+    /// - <https://github.com/Cuprate/cuprate/pull/320#discussion_r1819826080>
+    ///
+    /// [`ConnectionId::DEFAULT_STR`] is used when mapping to the RPC type.
+    pub connection_id: ConnectionId,
+}
+
+/// Marker type for `monerod`'s connection ID.
+///
+/// `connection_id` is a 128-bit `uuid` in `monerod`.
+/// `cuprated` does not support this field so it returns
+/// the default value in the RPC interface, an all 0-bit UUID.
+///
+/// This default value in string form is [`ConnectionId::DEFAULT_STR`].
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ConnectionId;
+
+impl ConnectionId {
+    /// [`str`] representation of a default connection ID.
+    pub const DEFAULT_STR: &str = "00000000000000000000000000000000";
+}
+
+/// Used in RPC's `sync_info`.
+///
+// TODO: fix docs after <https://github.com/Cuprate/cuprate/pull/320#discussion_r1811089758>
+// Data within [`crate::services::AddressBookResponse::Spans`].
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Span<A: NetZoneAddress> {
+    pub nblocks: u64,
+    pub rate: u32,
+    pub remote_address: A,
+    pub size: u64,
+    pub speed: u32,
+    pub start_block_height: u64,
+}
--- a/p2p/p2p/Cargo.toml
+++ b/p2p/p2p/Cargo.toml
@ -34,11 +34,5 @@ rand_distr = { workspace = true, features = ["std"] }
 tracing = { workspace = true, features = ["std", "attributes"] }
 borsh = { workspace = true, features = ["derive", "std"] }

-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-indexmap = { workspace = true }
-proptest = { workspace = true }
-tokio-test = { workspace = true }
-
 [lints]
 workspace = true
--- a/pruning/Cargo.toml
+++ b/pruning/Cargo.toml
@ -10,7 +10,7 @@ default = []
 borsh = ["dep:borsh"]

 [dependencies]
-cuprate-constants = { workspace = true }
+cuprate-constants = { workspace = true, features = ["block"] }
 cuprate-helper    = { workspace = true, features = ["cast"] }

 thiserror = { workspace = true }
--- a/rpc/interface/Cargo.toml
+++ b/rpc/interface/Cargo.toml
@ -10,28 +10,20 @@ keywords    = ["cuprate", "rpc", "interface"]

 [features]
 default  = ["dummy", "serde"]
-dummy    = []
+dummy    = ["dep:cuprate-helper", "dep:futures"]

 [dependencies]
 cuprate-epee-encoding = { workspace = true, default-features = false }
 cuprate-json-rpc      = { workspace = true, default-features = false }
 cuprate-rpc-types     = { workspace = true, features = ["serde", "epee"], default-features = false }
-cuprate-helper        = { workspace = true, features = ["asynch"], default-features = false }
+cuprate-helper        = { workspace = true, features = ["asynch"], default-features = false, optional = true }

 anyhow     = { workspace = true }
 axum       = { version = "0.7.5", features = ["json"], default-features = false }
 serde      = { workspace = true, optional = true }
-tower      = { workspace = true }
+tower      = { workspace = true, features = ["util"] }
 paste      = { workspace = true }
-futures    = { workspace = true }
-
-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-
-axum       = { version = "0.7.5", features = ["json", "tokio", "http2"] }
-serde_json = { workspace = true, features = ["std"] }
-tokio      = { workspace = true, features = ["full"] }
-ureq       = { version = "2.10.1", features = ["json"] }
+futures    = { workspace = true, optional = true }

 [lints]
 workspace = true
--- a/rpc/json-rpc/Cargo.toml
+++ b/rpc/json-rpc/Cargo.toml
@ -16,8 +16,5 @@ serde      = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["std"] }
 thiserror  = { workspace = true }

-[dev-dependencies]
-pretty_assertions = { workspace = true }
-
 [lints]
 workspace = true
--- a/rpc/types/Cargo.toml
+++ b/rpc/types/Cargo.toml
@ -10,22 +10,16 @@ keywords    = ["cuprate", "rpc", "types", "monero"]

 [features]
 default = ["serde", "epee"]
-serde   = ["dep:serde", "cuprate-fixed-bytes/serde"]
-epee    = ["dep:cuprate-epee-encoding"]
+serde   = ["dep:serde", "cuprate-fixed-bytes/serde", "cuprate-types/serde"]
+epee    = ["dep:cuprate-epee-encoding", "cuprate-types/epee"]

 [dependencies]
 cuprate-epee-encoding = { workspace = true, optional = true }
 cuprate-fixed-bytes   = { workspace = true }
-cuprate-types         = { workspace = true, default-features = false, features = ["epee", "serde"] }
+cuprate-types         = { workspace = true, default-features = false }

 paste = { workspace = true }
 serde = { workspace = true, optional = true }

-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-
-serde      = { workspace = true }
-serde_json = { workspace = true }
-
 [lints]
 workspace = true
--- a/rpc/types/src/base.rs
+++ b/rpc/types/src/base.rs
@ -58,61 +58,37 @@ pub struct ResponseBase {
 }

 impl ResponseBase {
-    /// `const` version of [`Default::default`].
-    ///
-    /// ```rust
-    /// use cuprate_rpc_types::{misc::*, base::*};
-    ///
-    /// let new = ResponseBase::new();
-    /// assert_eq!(new, ResponseBase {
-    ///     status: Status::Ok,
-    ///     untrusted: false,
-    /// });
-    /// ```
-    pub const fn new() -> Self {
-        Self {
-            status: Status::Ok,
-            untrusted: false,
-        }
-    }
-
-    /// Returns OK and trusted [`Self`].
+    /// [`Status::Ok`] and trusted [`Self`].
    ///
    /// This is the most common version of [`Self`].
    ///
    /// ```rust
    /// use cuprate_rpc_types::{misc::*, base::*};
    ///
-    /// let ok = ResponseBase::ok();
-    /// assert_eq!(ok, ResponseBase {
+    /// assert_eq!(ResponseBase::OK, ResponseBase {
    ///     status: Status::Ok,
    ///     untrusted: false,
    /// });
    /// ```
-    pub const fn ok() -> Self {
-        Self {
+    pub const OK: Self = Self {
        status: Status::Ok,
        untrusted: false,
-        }
-    }
+    };

-    /// Same as [`Self::ok`] but with [`Self::untrusted`] set to `true`.
+    /// Same as [`Self::OK`] but with [`Self::untrusted`] set to `true`.
    ///
    /// ```rust
    /// use cuprate_rpc_types::{misc::*, base::*};
    ///
-    /// let ok_untrusted = ResponseBase::ok_untrusted();
-    /// assert_eq!(ok_untrusted, ResponseBase {
+    /// assert_eq!(ResponseBase::OK_UNTRUSTED, ResponseBase {
    ///     status: Status::Ok,
    ///     untrusted: true,
    /// });
    /// ```
-    pub const fn ok_untrusted() -> Self {
-        Self {
+    pub const OK_UNTRUSTED: Self = Self {
        status: Status::Ok,
        untrusted: true,
-        }
-    }
+    };
 }

 #[cfg(feature = "epee")]
@ -148,9 +124,9 @@ impl AccessResponseBase {
    /// ```rust
    /// use cuprate_rpc_types::{misc::*, base::*};
    ///
-    /// let new = AccessResponseBase::new(ResponseBase::ok());
+    /// let new = AccessResponseBase::new(ResponseBase::OK);
    /// assert_eq!(new, AccessResponseBase {
-    ///     response_base: ResponseBase::ok(),
+    ///     response_base: ResponseBase::OK,
    ///     credits: 0,
    ///     top_hash: "".into(),
    /// });
@ -163,47 +139,41 @@ impl AccessResponseBase {
        }
    }

-    /// Returns OK and trusted [`Self`].
+    /// [`Status::Ok`] and trusted [`Self`].
    ///
    /// This is the most common version of [`Self`].
    ///
    /// ```rust
    /// use cuprate_rpc_types::{misc::*, base::*};
    ///
-    /// let ok = AccessResponseBase::ok();
-    /// assert_eq!(ok, AccessResponseBase {
-    ///     response_base: ResponseBase::ok(),
+    /// assert_eq!(AccessResponseBase::OK, AccessResponseBase {
+    ///     response_base: ResponseBase::OK,
    ///     credits: 0,
    ///     top_hash: "".into(),
    /// });
    /// ```
-    pub const fn ok() -> Self {
-        Self {
-            response_base: ResponseBase::ok(),
+    pub const OK: Self = Self {
+        response_base: ResponseBase::OK,
        credits: 0,
        top_hash: String::new(),
-        }
-    }
+    };

-    /// Same as [`Self::ok`] but with `untrusted` set to `true`.
+    /// Same as [`Self::OK`] but with `untrusted` set to `true`.
    ///
    /// ```rust
    /// use cuprate_rpc_types::{misc::*, base::*};
    ///
-    /// let ok_untrusted = AccessResponseBase::ok_untrusted();
-    /// assert_eq!(ok_untrusted, AccessResponseBase {
-    ///     response_base: ResponseBase::ok_untrusted(),
+    /// assert_eq!(AccessResponseBase::OK_UNTRUSTED, AccessResponseBase {
+    ///     response_base: ResponseBase::OK_UNTRUSTED,
    ///     credits: 0,
    ///     top_hash: "".into(),
    /// });
    /// ```
-    pub const fn ok_untrusted() -> Self {
-        Self {
-            response_base: ResponseBase::ok_untrusted(),
+    pub const OK_UNTRUSTED: Self = Self {
+        response_base: ResponseBase::OK_UNTRUSTED,
        credits: 0,
        top_hash: String::new(),
-        }
-    }
+    };
 }

 #[cfg(feature = "epee")]
--- a/rpc/types/src/bin.rs
+++ b/rpc/types/src/bin.rs
@ -20,12 +20,16 @@ use cuprate_types::BlockCompleteEntry;

 use crate::{
    base::AccessResponseBase,
-    defaults::{default_false, default_zero},
    macros::{define_request, define_request_and_response, define_request_and_response_doc},
-    misc::{BlockOutputIndices, GetOutputsOut, OutKeyBin, PoolInfoExtent, PoolTxInfo, Status},
+    misc::{BlockOutputIndices, GetOutputsOut, OutKeyBin, PoolTxInfo, Status},
    rpc_call::RpcCallValue,
 };

+#[cfg(any(feature = "epee", feature = "serde"))]
+use crate::defaults::{default_false, default_zero};
+#[cfg(feature = "epee")]
+use crate::misc::PoolInfoExtent;
+
 //---------------------------------------------------------------------------------------------------- Definitions
 define_request_and_response! {
    get_blocks_by_heightbin,
--- a/rpc/types/src/json.rs
+++ b/rpc/types/src/json.rs
@ -8,10 +8,6 @@ use serde::{Deserialize, Serialize};

 use crate::{
    base::{AccessResponseBase, ResponseBase},
-    defaults::{
-        default_false, default_height, default_one, default_string, default_true, default_vec,
-        default_zero,
-    },
    macros::define_request_and_response,
    misc::{
        AuxPow, BlockHeader, ChainInfo, ConnectionInfo, Distribution, GetBan,
@ -21,6 +17,12 @@ use crate::{
    rpc_call::RpcCallValue,
 };

+#[cfg(any(feature = "epee", feature = "serde"))]
+use crate::defaults::{
+    default_false, default_height, default_one, default_string, default_true, default_vec,
+    default_zero,
+};
+
 //---------------------------------------------------------------------------------------------------- Macro
 /// Adds a (de)serialization doc-test to a type in `json.rs`.
 ///
@ -184,7 +186,7 @@ define_request_and_response! {
    // <https://serde.rs/field-attrs.html#flatten>.
    #[doc = serde_doc_test!(
        GET_BLOCK_TEMPLATE_RESPONSE => GetBlockTemplateResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            blockhashing_blob: "1010f4bae0b4069d648e741d85ca0e7acb4501f051b27e9b107d3cd7a3f03aa7f776089117c81a00000000e0c20372be23d356347091025c5b5e8f2abf83ab618378565cce2b703491523401".into(),
            blocktemplate_blob: "1010f4bae0b4069d648e741d85ca0e7acb4501f051b27e9b107d3cd7a3f03aa7f776089117c81a0000000002c681c30101ff8a81c3010180e0a596bb11033b7eedf47baf878f3490cb20b696079c34bd017fe59b0d070e74d73ffabc4bb0e05f011decb630f3148d0163b3bd39690dde4078e4cfb69fecf020d6278a27bad10c58023c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into(),
            difficulty_top64: 0,
@ -240,7 +242,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_BLOCK_COUNT_RESPONSE => GetBlockCountResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            count: 3195019,
        }
    )]
@ -332,7 +334,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GENERATE_BLOCKS_RESPONSE => GenerateBlocksResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            blocks: vec!["49b712db7760e3728586f8434ee8bc8d7b3d410dac6bb6e98bf5845c83b917e4".into()],
            height: 9783,
        }
@ -357,7 +359,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_LAST_BLOCK_HEADER_RESPONSE => GetLastBlockHeaderResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            block_header: BlockHeader {
                block_size: 200419,
                block_weight: 200419,
@ -409,7 +411,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_BLOCK_HEADER_BY_HASH_RESPONSE => GetBlockHeaderByHashResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            block_headers: vec![],
            block_header: BlockHeader {
                block_size: 210,
@ -464,7 +466,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_BLOCK_HEADER_BY_HEIGHT_RESPONSE => GetBlockHeaderByHeightResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            block_header: BlockHeader {
                block_size: 210,
                block_weight: 210,
@ -519,7 +521,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_BLOCK_HEADERS_RANGE_RESPONSE => GetBlockHeadersRangeResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            headers: vec![
                BlockHeader {
                    block_size: 301413,
@ -601,7 +603,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_BLOCK_RESPONSE => GetBlockResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            blob: "1010c58bab9b06b27bdecfc6cd0a46172d136c08831cf67660377ba992332363228b1b722781e7807e07f502cef8a70101ff92f8a7010180e0a596bb1103d7cbf826b665d7a532c316982dc8dbc24f285cbc18bbcc27c7164cd9b3277a85d034019f629d8b36bd16a2bfce3ea80c31dc4d8762c67165aec21845494e32b7582fe00211000000297a787a000000000000000000000000".into(),
            block_header: BlockHeader {
                block_size: 106,
@ -654,11 +656,11 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_CONNECTIONS_RESPONSE => GetConnectionsResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            connections: vec![
                ConnectionInfo {
                    address: "3evk3kezfjg44ma6tvesy7rbxwwpgpympj45xar5fo4qajrsmkoaqdqd.onion:18083".into(),
-                    address_type: 4,
+                    address_type: cuprate_types::AddressType::Tor,
                    avg_download: 0,
                    avg_upload: 0,
                    connection_id: "22ef856d0f1d44cc95e84fecfd065fe2".into(),
@ -680,12 +682,12 @@ define_request_and_response! {
                    rpc_port: 0,
                    send_count: 3406572,
                    send_idle_time: 30,
-                    state: "normal".into(),
+                    state: cuprate_types::ConnectionState::Normal,
                    support_flags: 0
                },
                ConnectionInfo {
                    address: "4iykytmumafy5kjahdqc7uzgcs34s2vwsadfjpk4znvsa5vmcxeup2qd.onion:18083".into(),
-                    address_type: 4,
+                    address_type: cuprate_types::AddressType::Tor,
                    avg_download: 0,
                    avg_upload: 0,
                    connection_id: "c7734e15936f485a86d2b0534f87e499".into(),
@ -707,7 +709,7 @@ define_request_and_response! {
                    rpc_port: 0,
                    send_count: 3370566,
                    send_idle_time: 120,
-                    state: "normal".into(),
+                    state: cuprate_types::ConnectionState::Normal,
                    support_flags: 0
                }
            ],
@ -728,7 +730,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_INFO_RESPONSE => GetInfoResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            adjusted_time: 1721245289,
            alt_blocks_count: 16,
            block_size_limit: 600000,
@ -831,7 +833,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        HARD_FORK_INFO_RESPONSE => HardForkInfoResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            earliest_height: 2689608,
            enabled: true,
            state: 0,
@ -877,7 +879,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SET_BANS_RESPONSE => SetBansResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -892,7 +894,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_BANS_RESPONSE => GetBansResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            bans: vec![
                GetBan {
                    host: "104.248.206.131".into(),
@ -994,7 +996,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_OUTPUT_HISTOGRAM_RESPONSE => GetOutputHistogramResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            histogram: vec![HistogramEntry {
                amount: 20000000000,
                recent_instances: 0,
@ -1028,7 +1030,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_COINBASE_TX_SUM_RESPONSE => GetCoinbaseTxSumResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            emission_amount: 9387854817320,
            emission_amount_top64: 0,
            fee_amount: 83981380000,
@ -1057,7 +1059,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_VERSION_RESPONSE => GetVersionResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            current_height: 3195051,
            hard_forks: vec![
                HardforkEntry {
@ -1143,12 +1145,16 @@ define_request_and_response! {
    get_fee_estimate,
    cc73fe71162d564ffda8e549b79a350bca53c454 =>
    core_rpc_server_commands_defs.h => 2250..=2277,
-    GetFeeEstimate (empty),
-    Request {},
+
+    GetFeeEstimate,
+
+    Request {
+        grace_blocks: u64 = default_zero::<u64>(), "default_zero",
+    },

    #[doc = serde_doc_test!(
        GET_FEE_ESTIMATE_RESPONSE => GetFeeEstimateResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            fee: 20000,
            fees: vec![20000,80000,320000,4000000],
            quantization_mask: 10000,
@ -1170,7 +1176,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_ALTERNATE_CHAINS_RESPONSE => GetAlternateChainsResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            chains: vec![
                ChainInfo {
                    block_hash: "4826c7d45d7cf4f02985b5c405b0e5d7f92c8d25e015492ce19aa3b209295dce".into(),
@ -1238,7 +1244,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SYNC_INFO_RESPONSE => SyncInfoResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            height: 3195157,
            next_needed_pruning_seed: 0,
            overview: "[]".into(),
@ -1247,7 +1253,7 @@ define_request_and_response! {
                SyncInfoPeer {
                    info: ConnectionInfo {
                        address: "142.93.128.65:44986".into(),
-                        address_type: 1,
+                        address_type: cuprate_types::AddressType::Ipv4,
                        avg_download: 1,
                        avg_upload: 1,
                        connection_id: "a5803c4c2dac49e7b201dccdef54c862".into(),
@ -1269,14 +1275,14 @@ define_request_and_response! {
                        rpc_port: 18089,
                        send_count: 32235,
                        send_idle_time: 6,
-                        state: "normal".into(),
+                        state: cuprate_types::ConnectionState::Normal,
                        support_flags: 1
                    }
                },
                SyncInfoPeer {
                    info: ConnectionInfo {
                        address: "4iykytmumafy5kjahdqc7uzgcs34s2vwsadfjpk4znvsa5vmcxeup2qd.onion:18083".into(),
-                        address_type: 4,
+                        address_type: cuprate_types::AddressType::Tor,
                        avg_download: 0,
                        avg_upload: 0,
                        connection_id: "277f7c821bc546878c8bd29977e780f5".into(),
@ -1298,7 +1304,7 @@ define_request_and_response! {
                        rpc_port: 0,
                        send_count: 99120,
                        send_idle_time: 15,
-                        state: "normal".into(),
+                        state: cuprate_types::ConnectionState::Normal,
                        support_flags: 0
                    }
                }
@ -1328,7 +1334,7 @@ define_request_and_response! {
    // TODO: enable test after binary string impl.
    // #[doc = serde_doc_test!(
    //     GET_TRANSACTION_POOL_BACKLOG_RESPONSE => GetTransactionPoolBacklogResponse {
-    //         base: ResponseBase::ok(),
+    //         base: ResponseBase::OK,
    //         backlog: "...Binary...".into(),
    //     }
    // )]
@ -1370,7 +1376,7 @@ define_request_and_response! {
    // TODO: enable test after binary string impl.
    // #[doc = serde_doc_test!(
    //     GET_OUTPUT_DISTRIBUTION_RESPONSE => GetOutputDistributionResponse {
-    //         base: AccessResponseBase::ok(),
+    //         base: AccessResponseBase::OK,
    //         distributions: vec![Distribution::Uncompressed(DistributionUncompressed {
    //             start_height: 1462078,
    //             base: 0,
@ -1394,7 +1400,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_MINER_DATA_RESPONSE => GetMinerDataResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            already_generated_coins: 18186022843595960691,
            difficulty: "0x48afae42de".into(),
            height: 2731375,
@ -1447,7 +1453,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        PRUNE_BLOCKCHAIN_RESPONSE => PruneBlockchainResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            pruned: true,
            pruning_seed: 387,
        }
@ -1513,7 +1519,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        FLUSH_CACHE_RESPONSE => FlushCacheResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -1542,7 +1548,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        ADD_AUX_POW_RESPONSE => AddAuxPowResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            aux_pow: vec![AuxPow {
                hash: "7b35762de164b20885e15dbe656b1138db06bb402fa1796f5765a23933d8859a".into(),
                id: "3200b4ea97c3b2081cd4190b58e49572b2319fed00d030ad51809dff06b5d8c8".into(),
--- a/rpc/types/src/lib.rs
+++ b/rpc/types/src/lib.rs
@ -6,6 +6,7 @@
 )]

 mod constants;
+#[cfg(any(feature = "serde", feature = "epee"))]
 mod defaults;
 mod free;
 mod macros;
--- a/rpc/types/src/misc/distribution.rs
+++ b/rpc/types/src/misc/distribution.rs
@ -20,8 +20,8 @@ use cuprate_epee_encoding::{
    "rpc/core_rpc_server_commands_defs.h",
    45..=55
 )]
-#[cfg(feature = "epee")]
-fn compress_integer_array(_: &[u64]) -> error::Result<Vec<u8>> {
+#[cfg(any(feature = "epee", feature = "serde"))]
+fn compress_integer_array(_: &[u64]) -> Vec<u8> {
    todo!()
 }

@ -33,6 +33,7 @@ fn compress_integer_array(_: &[u64]) -> error::Result<Vec<u8>> {
    "rpc/core_rpc_server_commands_defs.h",
    57..=72
 )]
+#[cfg(any(feature = "epee", feature = "serde"))]
 fn decompress_integer_array(_: &[u8]) -> Vec<u64> {
    todo!()
 }
@ -135,12 +136,7 @@ fn serialize_distribution_as_compressed_data<S>(v: &Vec<u64>, s: S) -> Result<S:
 where
    S: serde::Serializer,
 {
-    match compress_integer_array(v) {
-        Ok(compressed_data) => compressed_data.serialize(s),
-        Err(_) => Err(serde::ser::Error::custom(
-            "error compressing distribution array",
-        )),
-    }
+    compress_integer_array(v).serialize(s)
 }

 /// Deserializer function for [`DistributionCompressedBinary::distribution`].
@ -256,7 +252,7 @@ impl EpeeObject for Distribution {
                distribution,
                amount,
            }) => {
-                let compressed_data = compress_integer_array(&distribution)?;
+                let compressed_data = compress_integer_array(&distribution);

                start_height.write(w)?;
                base.write(w)?;
--- a/rpc/types/src/misc/misc.rs
+++ b/rpc/types/src/misc/misc.rs
@ -11,10 +11,10 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "epee")]
 use cuprate_epee_encoding::epee_object;

-use crate::{
-    defaults::{default_string, default_zero},
-    macros::monero_definition_link,
-};
+use crate::macros::monero_definition_link;
+
+#[cfg(any(feature = "epee", feature = "serde"))]
+use crate::defaults::default_zero;

 //---------------------------------------------------------------------------------------------------- Macros
 /// This macro (local to this file) defines all the misc types.
@ -110,7 +110,7 @@ define_struct_and_impl_epee! {
    /// Used in [`crate::json::GetConnectionsResponse`].
    ConnectionInfo {
        address: String,
-        address_type: u8,
+        address_type: cuprate_types::AddressType,
        avg_download: u64,
        avg_upload: u64,
        connection_id: String,
@ -135,7 +135,7 @@ define_struct_and_impl_epee! {
        // Exists in the original definition, but isn't
        // used or (de)serialized for RPC purposes.
        // ssl: bool,
-        state: String,
+        state: cuprate_types::ConnectionState,
        support_flags: u32,
    }
 }
@ -148,7 +148,7 @@ define_struct_and_impl_epee! {
    )]
    /// Used in [`crate::json::SetBansRequest`].
    SetBan {
-        #[cfg_attr(feature = "serde", serde(default = "default_string"))]
+        #[cfg_attr(feature = "serde", serde(default = "crate::defaults::default_string"))]
        host: String,
        #[cfg_attr(feature = "serde", serde(default = "default_zero"))]
        ip: u32,
--- a/rpc/types/src/other.rs
+++ b/rpc/types/src/other.rs
@ -8,7 +8,6 @@ use serde::{Deserialize, Serialize};

 use crate::{
    base::{AccessResponseBase, ResponseBase},
-    defaults::{default_false, default_string, default_true, default_vec, default_zero},
    macros::define_request_and_response,
    misc::{
        GetOutputsOut, OutKey, Peer, PublicNode, SpentKeyImageInfo, Status, TxEntry, TxInfo,
@ -17,6 +16,9 @@ use crate::{
    RpcCallValue,
 };

+#[cfg(any(feature = "serde", feature = "epee"))]
+use crate::defaults::{default_false, default_string, default_true, default_vec, default_zero};
+
 //---------------------------------------------------------------------------------------------------- Macro
 /// Adds a (de)serialization doc-test to a type in `other.rs`.
 ///
@ -102,7 +104,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_HEIGHT_RESPONSE => GetHeightResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            hash: "68bb1a1cff8e2a44c3221e8e1aff80bc6ca45d06fa8eff4d2a3a7ac31d4efe3f".into(),
            height: 3195160,
        }
@ -157,7 +159,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_ALT_BLOCKS_HASHES_RESPONSE => GetAltBlocksHashesResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            blks_hashes: vec!["8ee10db35b1baf943f201b303890a29e7d45437bd76c2bd4df0d2f2ee34be109".into()],
        }
    )]
@ -187,7 +189,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        IS_KEY_IMAGE_SPENT_RESPONSE => IsKeyImageSpentResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            spent_status: vec![1, 1],
        }
    )]
@ -283,7 +285,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        START_MINING_RESPONSE => StartMiningResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -298,7 +300,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        STOP_MINING_RESPONSE => StopMiningResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -313,7 +315,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        MINING_STATUS_RESPONSE => MiningStatusResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            active: false,
            address: "".into(),
            bg_idle_threshold: 0,
@ -359,7 +361,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SAVE_BC_RESPONSE => SaveBcResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -385,7 +387,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_PEER_LIST_RESPONSE => GetPeerListResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            gray_list: vec![
                Peer {
                    host: "161.97.193.0".into(),
@ -467,7 +469,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SET_LOG_HASH_RATE_RESPONSE => SetLogHashRateResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -492,7 +494,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SET_LOG_LEVEL_RESPONSE => SetLogLevelResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
        }
    )]
    ResponseBase {}
@ -516,7 +518,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SET_LOG_CATEGORIES_RESPONSE => SetLogCategoriesResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            categories: "*:INFO".into(),
        }
    )]
@ -582,7 +584,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_TRANSACTION_POOL_STATS_RESPONSE => GetTransactionPoolStatsResponse {
-            base: AccessResponseBase::ok(),
+            base: AccessResponseBase::OK,
            pool_stats: TxpoolStats {
                bytes_max: 11843,
                bytes_med: 2219,
@ -644,7 +646,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_LIMIT_RESPONSE => GetLimitResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            limit_down: 1280000,
            limit_up: 1280000,
        }
@ -676,7 +678,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        SET_LIMIT_RESPONSE => SetLimitResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            limit_down: 1024,
            limit_up: 128,
        }
@ -707,7 +709,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        OUT_PEERS_RESPONSE => OutPeersResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            out_peers: 3232235535,
        }
    )]
@ -740,7 +742,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_NET_STATS_RESPONSE => GetNetStatsResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            start_time: 1721251858,
            total_bytes_in: 16283817214,
            total_bytes_out: 34225244079,
@ -779,7 +781,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_OUTS_RESPONSE => GetOutsResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            outs: vec![
                OutKey {
                    height: 51941,
@ -823,7 +825,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        UPDATE_RESPONSE => UpdateResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            auto_uri: "".into(),
            hash: "".into(),
            path: "".into(),
@ -860,7 +862,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        POP_BLOCKS_RESPONSE => PopBlocksResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            height: 76482,
        }
    )]
@ -879,7 +881,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_TRANSACTION_POOL_HASHES_RESPONSE => GetTransactionPoolHashesResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            tx_hashes: vec![
                "aa928aed888acd6152c60194d50a4df29b0b851be6169acf11b6a8e304dd6c03".into(),
                "794345f321a98f3135151f3056c0fdf8188646a8dab27de971428acf3551dd11".into(),
@ -929,7 +931,7 @@ define_request_and_response! {

    #[doc = serde_doc_test!(
        GET_PUBLIC_NODES_RESPONSE => GetPublicNodesResponse {
-            base: ResponseBase::ok(),
+            base: ResponseBase::OK,
            gray: vec![],
            white: vec![
                PublicNode {
--- a/storage/blockchain/Cargo.toml
+++ b/storage/blockchain/Cargo.toml
@ -9,44 +9,31 @@ repository  = "https://github.com/Cuprate/cuprate/tree/main/storage/cuprate-bloc
 keywords    = ["cuprate", "blockchain", "database"]

 [features]
-default     = ["heed", "service"]
+default     = ["heed"]
 # default     = ["redb", "service"]
 # default     = ["redb-memory", "service"]
 heed        = ["cuprate-database/heed"]
 redb        = ["cuprate-database/redb"]
 redb-memory = ["cuprate-database/redb-memory"]
-service     = ["dep:thread_local", "dep:rayon", "cuprate-helper/thread"]
+serde       = ["dep:serde", "cuprate-database/serde", "cuprate-database-service/serde"]

 [dependencies]
 cuprate-database         = { workspace = true }
 cuprate-database-service = { workspace = true }
-cuprate-helper           = { workspace = true, features = ["fs", "map", "crypto", "cast"] }
+cuprate-helper           = { workspace = true, features = ["fs", "map", "crypto", "tx", "thread"] }
 cuprate-types            = { workspace = true, features = ["blockchain"] }
 cuprate-pruning          = { workspace = true }

 bitflags         = { workspace = true, features = ["std", "serde", "bytemuck"] }
 bytemuck         = { workspace = true, features = ["must_cast", "derive", "min_const_generics", "extern_crate_alloc"] }
 curve25519-dalek = { workspace = true }
-rand             = { workspace = true }
+rand             = { workspace = true, features = ["std", "std_rng"] }
 monero-serai     = { workspace = true, features = ["std"] }
 serde            = { workspace = true, optional = true }

-# `service` feature.
 tower        = { workspace = true }
-thread_local = { workspace = true, optional = true }
-rayon        = { workspace = true, optional = true }
-
-[dev-dependencies]
-cuprate-constants  = { workspace = true }
-cuprate-helper     = { workspace = true, features = ["thread", "cast"] }
-cuprate-test-utils = { workspace = true }
-
-tokio             = { workspace = true, features = ["full"] }
-tempfile          = { workspace = true }
-pretty_assertions = { workspace = true }
-proptest          = { workspace = true }
-hex               = { workspace = true }
-hex-literal       = { workspace = true }
+thread_local = { workspace = true }
+rayon        = { workspace = true }

 [lints]
 workspace = true
--- a/storage/blockchain/README.md
+++ b/storage/blockchain/README.md
@ -32,9 +32,6 @@ use cuprate_blockchain::{
 This ensures the types/traits used from `cuprate_database` are the same ones used by `cuprate_blockchain` internally.

 # Feature flags
-The `service` module requires the `service` feature to be enabled.
-See the module for more documentation.
-
 Different database backends are enabled by the feature flags:
 - `heed` (LMDB)
 - `redb`
@ -45,7 +42,7 @@ The default is `heed`.
 <!-- FIXME: tracing should be behind a feature flag -->

 # Invariants when not using `service`
-`cuprate_blockchain` can be used without the `service` feature enabled but
+`cuprate_blockchain` can be used without the `service` module but
 there are some things that must be kept in mind when doing so.

 Failing to uphold these invariants may cause panics.
--- a/storage/blockchain/src/lib.rs
+++ b/storage/blockchain/src/lib.rs
@ -18,16 +18,12 @@ pub use free::open;

 pub mod config;
 pub mod ops;
+pub mod service;
 pub mod tables;
 pub mod types;

-//---------------------------------------------------------------------------------------------------- Feature-gated
-#[cfg(feature = "service")]
-pub mod service;
-
 //---------------------------------------------------------------------------------------------------- Private
 #[cfg(test)]
 pub(crate) mod tests;

-#[cfg(feature = "service")] // only needed in `service` for now
 pub(crate) mod unsafe_sendable;
--- a/storage/blockchain/src/service/mod.rs
+++ b/storage/blockchain/src/service/mod.rs
@ -10,8 +10,6 @@
 //!
 //! The system is managed by this crate, and only requires [`init`] by the user.
 //!
-//! This module must be enabled with the `service` feature.
-//!
 //! ## Handles
 //! The 2 handles to the database are:
 //! - [`BlockchainReadHandle`]
--- a/storage/blockchain/src/service/read.rs
+++ b/storage/blockchain/src/service/read.rs
@ -121,6 +121,8 @@ fn map_request(
        R::DatabaseSize => database_size(env),
        R::OutputHistogram(input) => output_histogram(env, input),
        R::CoinbaseTxSum { height, count } => coinbase_tx_sum(env, height, count),
+        R::AltChains => alt_chains(env),
+        R::AltChainCount => alt_chain_count(env),
    }

    /* SOMEDAY: post-request handling, run some code for each request? */
@ -640,3 +642,13 @@ fn output_histogram(env: &ConcreteEnv, input: OutputHistogramInput) -> ResponseR
 fn coinbase_tx_sum(env: &ConcreteEnv, height: usize, count: u64) -> ResponseResult {
    Ok(BlockchainResponse::CoinbaseTxSum(todo!()))
 }
+
+/// [`BlockchainReadRequest::AltChains`]
+fn alt_chains(env: &ConcreteEnv) -> ResponseResult {
+    Ok(BlockchainResponse::AltChains(todo!()))
+}
+
+/// [`BlockchainReadRequest::AltChainCount`]
+fn alt_chain_count(env: &ConcreteEnv) -> ResponseResult {
+    Ok(BlockchainResponse::AltChainCount(todo!()))
+}
--- a/storage/database/Cargo.toml
+++ b/storage/database/Cargo.toml
@ -9,16 +9,15 @@ repository  = "https://github.com/Cuprate/cuprate/tree/main/storage/database"
 keywords    = ["cuprate", "database"]

 [features]
-# default     = ["heed"]
+default     = ["heed"]
 # default     = ["redb"]
 # default     = ["redb-memory"]
-heed        = ["dep:heed", "dep:cuprate-helper"]
+heed        = []
 redb        = ["dep:redb"]
 redb-memory = ["redb"]

 [dependencies]
-# `usize_to_u64` needed in `heed`
-cuprate-helper = { workspace = true, features = ["cast"], optional = true }
+cuprate-helper = { workspace = true, features = ["cast"] }

 bytemuck  = { version = "1.18.0", features = ["must_cast", "derive", "min_const_generics", "extern_crate_alloc"] }
 bytes     = { workspace = true }
@ -28,14 +27,9 @@ paste     = { workspace = true }
 thiserror = { workspace = true }

 # Optional features.
-heed  = { version = "0.20.5", features = ["read-txn-no-tls"], optional = true }
+heed  = { version = "0.20.5", features = ["read-txn-no-tls"] }
 redb  = { version = "2.1.3", optional = true }
 serde = { workspace = true, optional = true }

-[dev-dependencies]
-bytemuck  = { version = "1.18.0", features = ["must_cast", "derive", "min_const_generics", "extern_crate_alloc"] }
-page_size = { version = "0.6.0" }
-tempfile  = { version = "3.12.0" }
-
 [lints]
 workspace = true
--- a/storage/database/src/backend/mod.rs
+++ b/storage/database/src/backend/mod.rs
@ -4,6 +4,8 @@ cfg_if::cfg_if! {
    // If both backends are enabled, fallback to `heed`.
    // This is useful when using `--all-features`.
    if #[cfg(all(feature = "redb", not(feature = "heed")))] {
+        use heed as _;
+
        mod redb;
        pub use redb::ConcreteEnv;
    } else {
--- a/storage/service/Cargo.toml
+++ b/storage/service/Cargo.toml
@ -8,14 +8,20 @@ authors     = ["Boog900"]
 repository  = "https://github.com/Cuprate/cuprate/tree/main/storage/service"
 keywords    = ["cuprate", "service", "database"]

+[features]
+default = ["heed"]
+heed = ["cuprate-database/heed"]
+redb = ["cuprate-database/redb"]
+redb-memorey = ["cuprate-database/redb-memory"]
+
 [dependencies]
 cuprate-database = { workspace = true }
-cuprate-helper   = { workspace = true, features = ["fs", "thread", "map"] }
+cuprate-helper   = { workspace = true, features = ["fs", "thread", "map", "asynch"] }

 serde     = { workspace = true, optional = true }
 rayon     = { workspace = true }
 tower     = { workspace = true }
-futures   = { workspace = true }
+futures   = { workspace = true, features = ["std"] }
 crossbeam = { workspace = true, features = ["std"] }

 [lints]
--- a/storage/txpool/Cargo.toml
+++ b/storage/txpool/Cargo.toml
@ -9,18 +9,17 @@ repository  = "https://github.com/Cuprate/cuprate/tree/main/storage/txpool"
 keywords    = ["cuprate", "txpool", "transaction", "pool", "database"]

 [features]
-default     = ["heed", "service"]
+default     = ["heed"]
 # default   = ["redb", "service"]
 # default   = ["redb-memory", "service"]
 heed        = ["cuprate-database/heed"]
 redb        = ["cuprate-database/redb"]
 redb-memory = ["cuprate-database/redb-memory"]
-service     = ["dep:tower", "dep:rayon", "dep:cuprate-database-service"]
 serde       = ["dep:serde", "cuprate-database/serde", "cuprate-database-service/serde"]

 [dependencies]
 cuprate-database         = { workspace = true, features = ["heed"] }
-cuprate-database-service = { workspace = true, optional = true }
+cuprate-database-service = { workspace = true }
 cuprate-types            = { workspace = true }
 cuprate-helper           = { workspace = true, default-features = false, features = ["constants"] }

@ -28,20 +27,13 @@ monero-serai             = { workspace = true, features = ["std"] }
 bytemuck                 = { workspace = true, features = ["must_cast", "derive", "min_const_generics", "extern_crate_alloc"] }
 bitflags                 = { workspace = true, features = ["std", "serde", "bytemuck"] }
 thiserror                = { workspace = true }
-hex                      = { workspace = true }
+hex                      = { workspace = true, features = ["std"] }
 blake3                   = { workspace = true, features = ["std"] }

-tower                    = { workspace = true, optional = true }
-rayon                    = { workspace = true, optional = true }
+tower                    = { workspace = true }
+rayon                    = { workspace = true }

 serde                    = { workspace = true, optional = true }

-[dev-dependencies]
-cuprate-test-utils = { workspace = true }
-
-tokio              = { workspace = true }
-tempfile           = { workspace = true }
-hex-literal        = { workspace = true }
-
 [lints]
 workspace = true
--- a/storage/txpool/README.md
+++ b/storage/txpool/README.md
@ -37,10 +37,6 @@ use cuprate_txpool::{
 This ensures the types/traits used from `cuprate_database` are the same ones used by `cuprate_txpool` internally.

 # Feature flags
-
-The `service` module requires the `service` feature to be enabled.
-See the module for more documentation.
-
 Different database backends are enabled by the feature flags:

 - `heed` (LMDB)
--- a/storage/txpool/src/lib.rs
+++ b/storage/txpool/src/lib.rs
@ -4,10 +4,12 @@
    clippy::significant_drop_tightening
 )]

+// Used in docs: <https://github.com/Cuprate/cuprate/pull/170#discussion_r1823644357>.
+use tower as _;
+
 pub mod config;
 mod free;
 pub mod ops;
-#[cfg(feature = "service")]
 pub mod service;
 pub mod tables;
 mod tx;
@ -20,8 +22,6 @@ pub use tx::TxEntry;
 //re-exports
 pub use cuprate_database;

-// TODO: remove when used.
-use tower as _;
 #[cfg(test)]
 mod test {
    use cuprate_test_utils as _;
--- a/storage/txpool/src/service.rs
+++ b/storage/txpool/src/service.rs
@ -10,8 +10,6 @@
 //!
 //! The system is managed by this crate, and only requires [`init`] by the user.
 //!
-//! This module must be enabled with the `service` feature.
-//!
 //! ## Handles
 //! The 2 handles to the database are:
 //! - [`TxpoolReadHandle`]
@ -42,7 +40,7 @@
 //! To interact with the database (whether reading or writing data),
 //! a `Request` can be sent using one of the above handles.
 //!
-//! Both the handles implement `tower::Service`, so they can be [`tower::Service::call`]ed.
+//! Both the handles implement [`tower::Service`], so they can be [`tower::Service::call`]ed.
 //!
 //! An `async`hronous channel will be returned from the call.
 //! This channel can be `.await`ed upon to (eventually) receive
--- a/storage/txpool/src/service/interface.rs
+++ b/storage/txpool/src/service/interface.rs
@ -35,7 +35,11 @@ pub enum TxpoolReadRequest {
    Backlog,

    /// Get the number of transactions in the pool.
-    Size,
+    Size {
+        /// If this is [`true`], the size returned will
+        /// include private transactions in the pool.
+        include_sensitive_txs: bool,
+    },
 }

 //---------------------------------------------------------------------------------------------------- TxpoolReadResponse
@ -66,7 +70,7 @@ pub enum TxpoolReadResponse {

    /// Response to [`TxpoolReadRequest::Backlog`].
    ///
-    /// The inner `Vec` contains information on all
+    /// The inner [`Vec`] contains information on all
    /// the transactions currently in the pool.
    Backlog(Vec<TxEntry>),

--- a/storage/txpool/src/service/read.rs
+++ b/storage/txpool/src/service/read.rs
@ -71,7 +71,9 @@ fn map_request(
        }
        TxpoolReadRequest::TxsForBlock(txs_needed) => txs_for_block(env, txs_needed),
        TxpoolReadRequest::Backlog => backlog(env),
-        TxpoolReadRequest::Size => size(env),
+        TxpoolReadRequest::Size {
+            include_sensitive_txs,
+        } => size(env, include_sensitive_txs),
    }
 }

@ -201,6 +203,6 @@ fn backlog(env: &ConcreteEnv) -> ReadResponseResult {

 /// [`TxpoolReadRequest::Size`].
 #[inline]
-fn size(env: &ConcreteEnv) -> ReadResponseResult {
+fn size(env: &ConcreteEnv, include_sensitive_txs: bool) -> ReadResponseResult {
    Ok(TxpoolReadResponse::Size(todo!()))
 }
--- a/storage/txpool/src/tx.rs
+++ b/storage/txpool/src/tx.rs
@ -5,6 +5,8 @@
 /// Used in [`TxpoolReadResponse::Backlog`](crate::service::interface::TxpoolReadResponse::Backlog).
 #[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct TxEntry {
+    /// The transaction's ID (hash).
+    pub id: [u8; 32],
    /// The transaction's weight.
    pub weight: u64,
    /// The transaction's fee.
--- a/test-utils/Cargo.toml
+++ b/test-utils/Cargo.toml
@ -26,9 +26,5 @@ tempfile                  = { workspace = true }
 paste                     = { workspace = true }
 borsh                     = { workspace = true, features = ["derive"]}

-[dev-dependencies]
-hex               = { workspace = true }
-pretty_assertions = { workspace = true }
-
 [lints]
 workspace = true
--- a/types/Cargo.toml
+++ b/types/Cargo.toml
@ -12,31 +12,28 @@ keywords    = ["cuprate", "types"]
 default    = ["blockchain", "epee", "serde", "json", "hex"]
 blockchain = []
 epee       = ["dep:cuprate-epee-encoding"]
-serde      = ["dep:serde"]
+serde      = ["dep:serde", "hex"]
 proptest   = ["dep:proptest",  "dep:proptest-derive"]
 json       = ["hex", "dep:cuprate-helper"]
-hex        = ["dep:hex"]
+# We sadly have no choice but to enable serde here as otherwise we will get warnings from the `hex` dep being unused.
+# This isn't too bad as `HexBytes` only makes sense with serde anyway.
+hex        = ["serde", "dep:hex"]

 [dependencies]
 cuprate-epee-encoding   = { workspace = true, optional = true, features = ["std"] }
 cuprate-helper          = { workspace = true, optional = true, features = ["cast"] }
-cuprate-fixed-bytes     = { workspace = true }
+cuprate-fixed-bytes     = { workspace = true, features = ["std", "serde"] }

 bytes            = { workspace = true }
 curve25519-dalek = { workspace = true }
 monero-serai     = { workspace = true }
 hex              = { workspace = true, features = ["serde", "alloc"], optional = true }
-serde            = { workspace = true, features = ["derive"], optional = true }
+serde            = { workspace = true, features = ["std", "derive"], optional = true }
 strum            = { workspace = true, features = ["derive"] }
 thiserror        = { workspace = true }

 proptest = { workspace = true, optional = true }
 proptest-derive  = { workspace = true, optional = true }

-[dev-dependencies]
-hex-literal       = { workspace = true }
-pretty_assertions = { workspace = true }
-serde_json        = { workspace = true, features = ["std"] }
-
 [lints]
 workspace = true
--- a/types/src/address_type.rs
+++ b/types/src/address_type.rs
@ -0,0 +1,147 @@
+//! Types of network addresses; used in P2P.
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "epee")]
+use cuprate_epee_encoding::{
+    error,
+    macros::bytes::{Buf, BufMut},
+    EpeeValue, Marker,
+};
+
+use strum::{
+    AsRefStr, Display, EnumCount, EnumIs, EnumString, FromRepr, IntoStaticStr, VariantArray,
+};
+
+/// An enumeration of address types.
+///
+/// Used in `cuprate_p2p` and `cuprate_types`
+///
+/// Original definition:
+/// - <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/epee/include/net/enums.h/#L49>
+///
+/// # Serde
+/// This type's `serde` implementation (de)serializes from a [`u8`].
+///
+/// ```rust
+/// use cuprate_types::AddressType as A;
+/// use serde_json::{to_string, from_str};
+///
+/// assert_eq!(from_str::<A>(&"0").unwrap(), A::Invalid);
+/// assert_eq!(from_str::<A>(&"1").unwrap(), A::Ipv4);
+/// assert_eq!(from_str::<A>(&"2").unwrap(), A::Ipv6);
+/// assert_eq!(from_str::<A>(&"3").unwrap(), A::I2p);
+/// assert_eq!(from_str::<A>(&"4").unwrap(), A::Tor);
+///
+/// assert_eq!(to_string(&A::Invalid).unwrap(), "0");
+/// assert_eq!(to_string(&A::Ipv4).unwrap(), "1");
+/// assert_eq!(to_string(&A::Ipv6).unwrap(), "2");
+/// assert_eq!(to_string(&A::I2p).unwrap(), "3");
+/// assert_eq!(to_string(&A::Tor).unwrap(), "4");
+/// ```
+#[derive(
+    Copy,
+    Clone,
+    Default,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    AsRefStr,
+    Display,
+    EnumCount,
+    EnumIs,
+    EnumString,
+    FromRepr,
+    IntoStaticStr,
+    VariantArray,
+)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(untagged, try_from = "u8", into = "u8"))]
+#[repr(u8)]
+pub enum AddressType {
+    #[default]
+    Invalid,
+    Ipv4,
+    Ipv6,
+    I2p,
+    Tor,
+}
+
+impl AddressType {
+    /// Convert [`Self`] to a [`u8`].
+    ///
+    /// ```rust
+    /// use cuprate_types::AddressType as A;
+    ///
+    /// assert_eq!(A::Invalid.to_u8(), 0);
+    /// assert_eq!(A::Ipv4.to_u8(), 1);
+    /// assert_eq!(A::Ipv6.to_u8(), 2);
+    /// assert_eq!(A::I2p.to_u8(), 3);
+    /// assert_eq!(A::Tor.to_u8(), 4);
+    /// ```
+    pub const fn to_u8(self) -> u8 {
+        self as u8
+    }
+
+    /// Convert a [`u8`] to a [`Self`].
+    ///
+    /// # Errors
+    /// This returns [`None`] if `u > 4`.
+    ///
+    /// ```rust
+    /// use cuprate_types::AddressType as A;
+    ///
+    /// assert_eq!(A::from_u8(0), Some(A::Invalid));
+    /// assert_eq!(A::from_u8(1), Some(A::Ipv4));
+    /// assert_eq!(A::from_u8(2), Some(A::Ipv6));
+    /// assert_eq!(A::from_u8(3), Some(A::I2p));
+    /// assert_eq!(A::from_u8(4), Some(A::Tor));
+    /// assert_eq!(A::from_u8(5), None);
+    /// ```
+    pub const fn from_u8(u: u8) -> Option<Self> {
+        Some(match u {
+            0 => Self::Invalid,
+            1 => Self::Ipv4,
+            2 => Self::Ipv6,
+            3 => Self::I2p,
+            4 => Self::Tor,
+            _ => return None,
+        })
+    }
+}
+
+impl From<AddressType> for u8 {
+    fn from(value: AddressType) -> Self {
+        value.to_u8()
+    }
+}
+
+impl TryFrom<u8> for AddressType {
+    type Error = u8;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match Self::from_u8(value) {
+            Some(s) => Ok(s),
+            None => Err(value),
+        }
+    }
+}
+
+#[cfg(feature = "epee")]
+impl EpeeValue for AddressType {
+    const MARKER: Marker = u8::MARKER;
+
+    fn read<B: Buf>(r: &mut B, marker: &Marker) -> error::Result<Self> {
+        let u = u8::read(r, marker)?;
+        Self::from_u8(u).ok_or(error::Error::Format("u8 was greater than 4"))
+    }
+
+    fn write<B: BufMut>(self, w: &mut B) -> error::Result<()> {
+        let u = self.to_u8();
+        u8::write(u, w)?;
+        Ok(())
+    }
+}
--- a/types/src/block_complete_entry.rs
+++ b/types/src/block_complete_entry.rs
@ -136,7 +136,7 @@ impl TransactionBlobs {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PrunedTxBlobEntry {
    /// The transaction.
-    pub tx: Bytes,
+    pub blob: Bytes,
    /// The prunable transaction hash.
    pub prunable_hash: ByteArray<32>,
 }
@ -144,7 +144,7 @@ pub struct PrunedTxBlobEntry {
 #[cfg(feature = "epee")]
 epee_object!(
    PrunedTxBlobEntry,
-    tx: Bytes,
+    blob: Bytes,
    prunable_hash: ByteArray<32>,
 );

--- a/types/src/blockchain.rs
+++ b/types/src/blockchain.rs
@ -12,7 +12,8 @@ use monero_serai::block::Block;

 use crate::{
    types::{Chain, ExtendedBlockHeader, OutputOnChain, VerifiedBlockInformation},
-    AltBlockInformation, ChainId, CoinbaseTxSum, OutputHistogramEntry, OutputHistogramInput,
+    AltBlockInformation, ChainId, ChainInfo, CoinbaseTxSum, OutputHistogramEntry,
+    OutputHistogramInput,
 };

 //---------------------------------------------------------------------------------------------------- ReadRequest
@ -128,6 +129,12 @@ pub enum BlockchainReadRequest {
    ///
    /// TODO: document fields after impl.
    CoinbaseTxSum { height: usize, count: u64 },
+
+    /// Get information on all alternative chains.
+    AltChains,
+
+    /// Get the amount of alternative chains that exist.
+    AltChainCount,
 }

 //---------------------------------------------------------------------------------------------------- WriteRequest
@ -276,6 +283,12 @@ pub enum BlockchainResponse {
    /// Response to [`BlockchainReadRequest::CoinbaseTxSum`].
    CoinbaseTxSum(CoinbaseTxSum),

+    /// Response to [`BlockchainReadRequest::AltChains`].
+    AltChains(Vec<ChainInfo>),
+
+    /// Response to [`BlockchainReadRequest::AltChainCount`].
+    AltChainCount(usize),
+
    //------------------------------------------------------ Writes
    /// A generic Ok response to indicate a request was successfully handled.
    ///
--- a/types/src/connection_state.rs
+++ b/types/src/connection_state.rs
@ -0,0 +1,148 @@
+//! [`ConnectionState`].
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "epee")]
+use cuprate_epee_encoding::{
+    error,
+    macros::bytes::{Buf, BufMut},
+    EpeeValue, Marker,
+};
+
+use strum::{
+    AsRefStr, Display, EnumCount, EnumIs, EnumString, FromRepr, IntoStaticStr, VariantArray,
+};
+
+/// An enumeration of P2P connection states.
+///
+/// Used in `cuprate_p2p` and `cuprate_rpc_types`.
+///
+/// Original definition:
+/// - <https://github.com/monero-project/monero/blob/893916ad091a92e765ce3241b94e706ad012b62a/src/cryptonote_basic/connection_context.h#L49>
+///
+/// # Serde
+/// This type's `serde` implementation depends on `snake_case`.
+///
+/// ```rust
+/// use cuprate_types::ConnectionState as C;
+/// use serde_json::to_string;
+///
+/// assert_eq!(to_string(&C::BeforeHandshake).unwrap(), r#""before_handshake""#);
+/// assert_eq!(to_string(&C::Synchronizing).unwrap(), r#""synchronizing""#);
+/// assert_eq!(to_string(&C::Standby).unwrap(), r#""standby""#);
+/// assert_eq!(to_string(&C::Idle).unwrap(), r#""idle""#);
+/// assert_eq!(to_string(&C::Normal).unwrap(), r#""normal""#);
+///
+/// assert_eq!(C::BeforeHandshake.to_string(), "before_handshake");
+/// assert_eq!(C::Synchronizing.to_string(), "synchronizing");
+/// assert_eq!(C::Standby.to_string(), "standby");
+/// assert_eq!(C::Idle.to_string(), "idle");
+/// assert_eq!(C::Normal.to_string(), "normal");
+/// ```
+#[derive(
+    Copy,
+    Clone,
+    Default,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    AsRefStr,
+    Display,
+    EnumCount,
+    EnumIs,
+    EnumString,
+    FromRepr,
+    IntoStaticStr,
+    VariantArray,
+)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] // cuprate-rpc-types depends on snake_case
+#[strum(serialize_all = "snake_case")]
+#[repr(u8)]
+pub enum ConnectionState {
+    BeforeHandshake,
+    Synchronizing,
+    Standby,
+    Idle,
+    #[default]
+    Normal,
+}
+
+impl ConnectionState {
+    /// Convert [`Self`] to a [`u8`].
+    ///
+    /// ```rust
+    /// use cuprate_types::ConnectionState as C;
+    ///
+    /// assert_eq!(C::BeforeHandshake.to_u8(), 0);
+    /// assert_eq!(C::Synchronizing.to_u8(), 1);
+    /// assert_eq!(C::Standby.to_u8(), 2);
+    /// assert_eq!(C::Idle.to_u8(), 3);
+    /// assert_eq!(C::Normal.to_u8(), 4);
+    /// ```
+    pub const fn to_u8(self) -> u8 {
+        self as u8
+    }
+
+    /// Convert a [`u8`] to a [`Self`].
+    ///
+    /// # Errors
+    /// This returns [`None`] if `u > 4`.
+    ///
+    /// ```rust
+    /// use cuprate_types::ConnectionState as C;
+    ///
+    /// assert_eq!(C::from_u8(0), Some(C::BeforeHandshake));
+    /// assert_eq!(C::from_u8(1), Some(C::Synchronizing));
+    /// assert_eq!(C::from_u8(2), Some(C::Standby));
+    /// assert_eq!(C::from_u8(3), Some(C::Idle));
+    /// assert_eq!(C::from_u8(4), Some(C::Normal));
+    /// assert_eq!(C::from_u8(5), None);
+    /// ```
+    pub const fn from_u8(u: u8) -> Option<Self> {
+        Some(match u {
+            0 => Self::BeforeHandshake,
+            1 => Self::Synchronizing,
+            2 => Self::Standby,
+            3 => Self::Idle,
+            4 => Self::Normal,
+            _ => return None,
+        })
+    }
+}
+
+impl From<ConnectionState> for u8 {
+    fn from(value: ConnectionState) -> Self {
+        value.to_u8()
+    }
+}
+
+impl TryFrom<u8> for ConnectionState {
+    type Error = u8;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match Self::from_u8(value) {
+            Some(s) => Ok(s),
+            None => Err(value),
+        }
+    }
+}
+
+#[cfg(feature = "epee")]
+impl EpeeValue for ConnectionState {
+    const MARKER: Marker = u8::MARKER;
+
+    fn read<B: Buf>(r: &mut B, marker: &Marker) -> error::Result<Self> {
+        let u = u8::read(r, marker)?;
+        Self::from_u8(u).ok_or(error::Error::Format("u8 was greater than 4"))
+    }
+
+    fn write<B: BufMut>(self, w: &mut B) -> error::Result<()> {
+        let u = self.to_u8();
+        u8::write(u, w)?;
+        Ok(())
+    }
+}
--- a/types/src/hex.rs
+++ b/types/src/hex.rs
@ -22,6 +22,7 @@ pub struct HexBytes<const N: usize>(
    #[cfg_attr(feature = "serde", serde(with = "hex::serde"))] pub [u8; N],
 );

+#[cfg(feature = "serde")]
 impl<'de, const N: usize> Deserialize<'de> for HexBytes<N>
 where
    [u8; N]: hex::FromHex,
--- a/types/src/json/block.rs
+++ b/types/src/json/block.rs
@ -51,17 +51,17 @@ impl From<block::Block> for Block {
 /// [`Block::miner_tx`].
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[serde(untagged)]
+#[cfg_attr(feature = "serde", serde(untagged))]
 pub enum MinerTransaction {
    V1 {
        /// This field is [flattened](https://serde.rs/field-attrs.html#flatten).
-        #[serde(flatten)]
+        #[cfg_attr(feature = "serde", serde(flatten))]
        prefix: MinerTransactionPrefix,
        signatures: [(); 0],
    },
    V2 {
        /// This field is [flattened](https://serde.rs/field-attrs.html#flatten).
-        #[serde(flatten)]
+        #[cfg_attr(feature = "serde", serde(flatten))]
        prefix: MinerTransactionPrefix,
        rct_signatures: MinerTransactionRctSignatures,
    },
--- a/types/src/json/output.rs
+++ b/types/src/json/output.rs
@ -20,7 +20,7 @@ pub struct Output {
 /// [`Output::target`].
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[serde(untagged)]
+#[cfg_attr(feature = "serde", serde(untagged))]
 pub enum Target {
    Key { key: HexBytes<32> },
    TaggedKey { tagged_key: TaggedKey },
--- a/types/src/json/tx.rs
+++ b/types/src/json/tx.rs
@ -24,17 +24,17 @@ use crate::{
 /// - [`/get_transaction_pool` -> `tx_json`](https://www.getmonero.org/resources/developer-guides/daemon-rpc.html#get_transaction_pool)
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[serde(untagged)]
+#[cfg_attr(feature = "serde", serde(untagged))]
 pub enum Transaction {
    V1 {
        /// This field is [flattened](https://serde.rs/field-attrs.html#flatten).
-        #[serde(flatten)]
+        #[cfg_attr(feature = "serde", serde(flatten))]
        prefix: TransactionPrefix,
        signatures: Vec<HexBytes<64>>,
    },
    V2 {
        /// This field is [flattened](https://serde.rs/field-attrs.html#flatten).
-        #[serde(flatten)]
+        #[cfg_attr(feature = "serde", serde(flatten))]
        prefix: TransactionPrefix,
        rct_signatures: RctSignatures,
        /// This field is [`Some`] if [`Self::V2::rct_signatures`]
--- a/types/src/lib.rs
+++ b/types/src/lib.rs
@ -9,20 +9,25 @@
 //
 // Documentation for each module is located in the respective file.

+mod address_type;
 mod block_complete_entry;
+mod connection_state;
 mod hard_fork;
 mod transaction_verification_data;
 mod types;

+pub use address_type::AddressType;
 pub use block_complete_entry::{BlockCompleteEntry, PrunedTxBlobEntry, TransactionBlobs};
+pub use connection_state::ConnectionState;
 pub use hard_fork::{HardFork, HardForkError};
 pub use transaction_verification_data::{
    CachedVerificationState, TransactionVerificationData, TxVersion,
 };
 pub use types::{
-    AltBlockInformation, Chain, ChainId, ChainInfo, CoinbaseTxSum, ExtendedBlockHeader,
-    FeeEstimate, HardForkInfo, MinerData, MinerDataTxBacklogEntry, OutputHistogramEntry,
-    OutputHistogramInput, OutputOnChain, VerifiedBlockInformation, VerifiedTransactionInformation,
+    AddAuxPow, AltBlockInformation, AuxPow, Chain, ChainId, ChainInfo, CoinbaseTxSum,
+    ExtendedBlockHeader, FeeEstimate, HardForkInfo, MinerData, MinerDataTxBacklogEntry,
+    OutputHistogramEntry, OutputHistogramInput, OutputOnChain, VerifiedBlockInformation,
+    VerifiedTransactionInformation,
 };

 //---------------------------------------------------------------------------------------------------- Feature-gated
--- a/types/src/types.rs
+++ b/types/src/types.rs
@ -177,8 +177,6 @@ pub struct OutputHistogramEntry {
 pub struct CoinbaseTxSum {
    pub emission_amount: u128,
    pub fee_amount: u128,
-    pub wide_emission_amount: u128,
-    pub wide_fee_amount: u128,
 }

 /// Data to create a custom block template.
@ -242,7 +240,23 @@ pub struct ChainInfo {
    pub height: u64,
    pub length: u64,
    pub main_chain_parent_block: [u8; 32],
-    pub wide_difficulty: u128,
+}
+
+/// Used in RPC's `add_aux_pow`.
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct AuxPow {
+    pub id: [u8; 32],
+    pub hash: [u8; 32],
+}
+
+/// Used in RPC's `add_aux_pow`.
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct AddAuxPow {
+    pub blocktemplate_blob: Vec<u8>,
+    pub blockhashing_blob: Vec<u8>,
+    pub merkle_root: [u8; 32],
+    pub merkle_tree_depth: u64,
+    pub aux_pow: Vec<AuxPow>,
 }

 //---------------------------------------------------------------------------------------------------- Tests