Merge branch 'main' into lints-6

helper/Cargo.toml

@@ -9,8 +9,8 @@ repository = "https://github.com/Cuprate/cuprate/tree/main/consensus"
 
 
 [features]
-# All features on by default.
+# All features off by default.
-default   = ["std", "atomic", "asynch", "cast", "fs", "num", "map", "time", "thread", "constants"]
+default   = []
 std       = []
 atomic    = ["dep:crossbeam"]
 asynch    = ["dep:futures", "dep:rayon"]
@@ -21,6 +21,7 @@ num       = []
 map       = ["cast", "dep:monero-serai"]
 time      = ["dep:chrono", "std"]
 thread    = ["std", "dep:target_os_lib"]
+tx        = ["dep:monero-serai"]
 
 [dependencies]
 crossbeam    = { workspace = true, optional = true }
@@ -40,6 +41,7 @@ target_os_lib = { package = "libc", version = "0.2.151", optional = true }
 
 [dev-dependencies]
 tokio            = { workspace = true, features = ["full"] }
+curve25519-dalek = { workspace = true }
 
 [lints]
 workspace = true

helper/src/lib.rs

@@ -31,6 +31,8 @@ pub mod thread;
 #[cfg(feature = "time")]
 pub mod time;
 
+#[cfg(feature = "tx")]
+pub mod tx;
 //---------------------------------------------------------------------------------------------------- Private Usage
 
 //----------------------------------------------------------------------------------------------------

helper/src/tx.rs

@@ -0,0 +1,70 @@
+//! Utils for working with [`Transaction`]
+
+use monero_serai::transaction::{Input, Transaction};
+
+/// Calculates the fee of the [`Transaction`].
+///
+/// # Panics
+/// This will panic if the inputs overflow or the transaction outputs too much, so should only
+/// be used on known to be valid txs.
+pub fn tx_fee(tx: &Transaction) -> u64 {
+    let mut fee = 0_u64;
+
+    match &tx {
+        Transaction::V1 { prefix, .. } => {
+            for input in &prefix.inputs {
+                match input {
+                    Input::Gen(_) => return 0,
+                    Input::ToKey { amount, .. } => {
+                        fee = fee.checked_add(amount.unwrap_or(0)).unwrap();
+                    }
+                }
+            }
+
+            for output in &prefix.outputs {
+                fee = fee.checked_sub(output.amount.unwrap_or(0)).unwrap();
+            }
+        }
+        Transaction::V2 { proofs, .. } => {
+            fee = proofs.as_ref().unwrap().base.fee;
+        }
+    };
+
+    fee
+}
+
+#[cfg(test)]
+mod test {
+    use curve25519_dalek::{edwards::CompressedEdwardsY, EdwardsPoint};
+    use monero_serai::transaction::{NotPruned, Output, Timelock, TransactionPrefix};
+
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "called `Option::unwrap()` on a `None` value")]
+    fn tx_fee_panic() {
+        let input = Input::ToKey {
+            amount: Some(u64::MAX),
+            key_offsets: vec![],
+            key_image: EdwardsPoint::default(),
+        };
+
+        let output = Output {
+            amount: Some(u64::MAX),
+            key: CompressedEdwardsY::default(),
+            view_tag: None,
+        };
+
+        let tx = Transaction::<NotPruned>::V1 {
+            prefix: TransactionPrefix {
+                additional_timelock: Timelock::None,
+                inputs: vec![input; 2],
+                outputs: vec![output],
+                extra: vec![],
+            },
+            signatures: vec![],
+        };
+
+        tx_fee(&tx);
+    }
+}

net/fixed-bytes/Cargo.toml

@@ -17,3 +17,6 @@ serde = { workspace = true, features = ["derive"], optional = true }
 
 [dev-dependencies]
 serde_json = { workspace = true, features = ["std"] }
+
+[lints]
+workspace = true

net/fixed-bytes/src/lib.rs

@@ -22,17 +22,15 @@ pub enum FixedByteError {
 }
 
 impl FixedByteError {
-    fn field_name(&self) -> &'static str {
+    const fn field_name(&self) -> &'static str {
         match self {
-            FixedByteError::InvalidLength => "input",
+            Self::InvalidLength => "input",
         }
     }
 
-    fn field_data(&self) -> &'static str {
+    const fn field_data(&self) -> &'static str {
         match self {
-            FixedByteError::InvalidLength => {
+            Self::InvalidLength => "Cannot create fix byte array, input has invalid length.",
-                "Cannot create fix byte array, input has invalid length."
-            }
         }
     }
 }
@@ -82,7 +80,7 @@ impl<const N: usize> ByteArray<N> {
 
 impl<const N: usize> From<[u8; N]> for ByteArray<N> {
     fn from(value: [u8; N]) -> Self {
-        ByteArray(Bytes::copy_from_slice(&value))
+        Self(Bytes::copy_from_slice(&value))
     }
 }
 
@@ -101,7 +99,7 @@ impl<const N: usize> TryFrom<Bytes> for ByteArray<N> {
         if value.len() != N {
             return Err(FixedByteError::InvalidLength);
         }
-        Ok(ByteArray(value))
+        Ok(Self(value))
     }
 }
 
@@ -112,7 +110,7 @@ impl<const N: usize> TryFrom<Vec<u8>> for ByteArray<N> {
         if value.len() != N {
             return Err(FixedByteError::InvalidLength);
         }
-        Ok(ByteArray(Bytes::from(value)))
+        Ok(Self(Bytes::from(value)))
     }
 }
 
@@ -142,11 +140,11 @@ impl<'de, const N: usize> Deserialize<'de> for ByteArrayVec<N> {
 }
 
 impl<const N: usize> ByteArrayVec<N> {
-    pub fn len(&self) -> usize {
+    pub const fn len(&self) -> usize {
         self.0.len() / N
     }
 
-    pub fn is_empty(&self) -> bool {
+    pub const fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
@@ -162,6 +160,7 @@ impl<const N: usize> ByteArrayVec<N> {
     ///
     /// # Panics
     /// Panics if at > len.
+    #[must_use]
     pub fn split_off(&mut self, at: usize) -> Self {
         Self(self.0.split_off(at * N))
     }
@@ -169,9 +168,9 @@ impl<const N: usize> ByteArrayVec<N> {
 
 impl<const N: usize> From<&ByteArrayVec<N>> for Vec<[u8; N]> {
     fn from(value: &ByteArrayVec<N>) -> Self {
-        let mut out = Vec::with_capacity(value.len());
+        let mut out = Self::with_capacity(value.len());
         for i in 0..value.len() {
-            out.push(value[i])
+            out.push(value[i]);
         }
 
         out
@@ -181,11 +180,11 @@ impl<const N: usize> From<&ByteArrayVec<N>> for Vec<[u8; N]> {
 impl<const N: usize> From<Vec<[u8; N]>> for ByteArrayVec<N> {
     fn from(value: Vec<[u8; N]>) -> Self {
         let mut bytes = BytesMut::with_capacity(N * value.len());
-        for i in value.into_iter() {
+        for i in value {
-            bytes.extend_from_slice(&i)
+            bytes.extend_from_slice(&i);
         }
 
-        ByteArrayVec(bytes.freeze())
+        Self(bytes.freeze())
     }
 }
 
@@ -197,13 +196,13 @@ impl<const N: usize> TryFrom<Bytes> for ByteArrayVec<N> {
             return Err(FixedByteError::InvalidLength);
         }
 
-        Ok(ByteArrayVec(value))
+        Ok(Self(value))
     }
 }
 
 impl<const N: usize> From<[u8; N]> for ByteArrayVec<N> {
     fn from(value: [u8; N]) -> Self {
-        ByteArrayVec(Bytes::copy_from_slice(value.as_slice()))
+        Self(Bytes::copy_from_slice(value.as_slice()))
     }
 }
 
@@ -211,11 +210,11 @@ impl<const N: usize, const LEN: usize> From<[[u8; N]; LEN]> for ByteArrayVec<N>
     fn from(value: [[u8; N]; LEN]) -> Self {
         let mut bytes = BytesMut::with_capacity(N * LEN);
 
-        for val in value.into_iter() {
+        for val in value {
             bytes.put_slice(val.as_slice());
         }
 
-        ByteArrayVec(bytes.freeze())
+        Self(bytes.freeze())
     }
 }
 
@@ -227,7 +226,7 @@ impl<const N: usize> TryFrom<Vec<u8>> for ByteArrayVec<N> {
             return Err(FixedByteError::InvalidLength);
         }
 
-        Ok(ByteArrayVec(Bytes::from(value)))
+        Ok(Self(Bytes::from(value)))
     }
 }
 
@@ -235,9 +234,12 @@ impl<const N: usize> Index<usize> for ByteArrayVec<N> {
     type Output = [u8; N];
 
     fn index(&self, index: usize) -> &Self::Output {
-        if (index + 1) * N > self.0.len() {
+        assert!(
-            panic!("Index out of range, idx: {}, length: {}", index, self.len());
+            (index + 1) * N <= self.0.len(),
-        }
+            "Index out of range, idx: {}, length: {}",
+            index,
+            self.len()
+        );
 
         self.0[index * N..(index + 1) * N]
             .as_ref()

net/wire/Cargo.toml

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

net/wire/src/network_address.rs

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

net/wire/src/network_address/epee_builder.rs

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

net/wire/src/p2p.rs

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

net/wire/src/p2p/admin.rs

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

net/wire/src/p2p/common.rs

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

net/wire/src/p2p/protocol.rs

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

p2p/address-book/Cargo.toml

@@ -8,7 +8,6 @@ authors = ["Boog900"]
 
 [dependencies]
 cuprate-pruning = { path = "../../pruning" }
-cuprate-wire = { path= "../../net/wire" }
 cuprate-p2p-core = { path = "../p2p-core" }
 
 tower = { workspace = true, features = ["util"] }
@@ -29,3 +28,6 @@ borsh = { workspace = true, features = ["derive", "std"]}
 cuprate-test-utils = {path = "../../test-utils"}
 
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"]}
+
+[lints]
+workspace = true

p2p/address-book/src/book.rs

@@ -36,7 +36,7 @@ use crate::{
 mod tests;
 
 /// An entry in the connected list.
-pub struct ConnectionPeerEntry<Z: NetworkZone> {
+pub(crate) struct ConnectionPeerEntry<Z: NetworkZone> {
     addr: Option<Z::Addr>,
     id: u64,
     handle: ConnectionHandle,
@@ -109,14 +109,14 @@ impl<Z: BorshNetworkZone> AddressBook<Z> {
             match handle.poll_unpin(cx) {
                 Poll::Pending => return,
                 Poll::Ready(Ok(Err(e))) => {
-                    tracing::error!("Could not save peer list to disk, got error: {}", e)
+                    tracing::error!("Could not save peer list to disk, got error: {e}");
                 }
                 Poll::Ready(Err(e)) => {
                     if e.is_panic() {
                         panic::resume_unwind(e.into_panic())
                     }
                 }
-                _ => (),
+                Poll::Ready(_) => (),
             }
         }
         // the task is finished.
@@ -144,6 +144,7 @@ impl<Z: BorshNetworkZone> AddressBook<Z> {
         let mut internal_addr_disconnected = Vec::new();
         let mut addrs_to_ban = Vec::new();
 
+        #[expect(clippy::iter_over_hash_type, reason = "ordering doesn't matter here")]
         for (internal_addr, peer) in &mut self.connected_peers {
             if let Some(time) = peer.handle.check_should_ban() {
                 match internal_addr {
@@ -158,7 +159,7 @@ impl<Z: BorshNetworkZone> AddressBook<Z> {
             }
         }
 
-        for (addr, time) in addrs_to_ban.into_iter() {
+        for (addr, time) in addrs_to_ban {
             self.ban_peer(addr, time);
         }
 
@@ -172,12 +173,7 @@ impl<Z: BorshNetworkZone> AddressBook<Z> {
                     .remove(&addr);
 
                 // If the amount of peers with this ban id is 0 remove the whole set.
-                if self
+                if self.connected_peers_ban_id[&addr.ban_id()].is_empty() {
-                    .connected_peers_ban_id
-                    .get(&addr.ban_id())
-                    .unwrap()
-                    .is_empty()
-                {
                     self.connected_peers_ban_id.remove(&addr.ban_id());
                 }
                 // remove the peer from the anchor list.
@@ -188,7 +184,7 @@ impl<Z: BorshNetworkZone> AddressBook<Z> {
 
     fn ban_peer(&mut self, addr: Z::Addr, time: Duration) {
         if self.banned_peers.contains_key(&addr.ban_id()) {
-            tracing::error!("Tried to ban peer twice, this shouldn't happen.")
+            tracing::error!("Tried to ban peer twice, this shouldn't happen.");
         }
 
         if let Some(connected_peers_with_ban_id) = self.connected_peers_ban_id.get(&addr.ban_id()) {
@@ -242,10 +238,10 @@ impl<Z: BorshNetworkZone> AddressBook<Z> {
         peer_list.retain_mut(|peer| {
             peer.adr.make_canonical();
 
-            if !peer.adr.should_add_to_peer_list() {
+            if peer.adr.should_add_to_peer_list() {
-                false
-            } else {
                 !self.is_peer_banned(&peer.adr)
+            } else {
+                false
             }
             // TODO: check rpc/ p2p ports not the same
         });
@@ -391,7 +387,7 @@ impl<Z: BorshNetworkZone> Service<AddressBookRequest<Z>> for AddressBook<Z> {
                         rpc_credits_per_hash,
                     },
                 )
-                .map(|_| AddressBookResponse::Ok),
+                .map(|()| AddressBookResponse::Ok),
             AddressBookRequest::IncomingPeerList(peer_list) => {
                 self.handle_incoming_peer_list(peer_list);
                 Ok(AddressBookResponse::Ok)

p2p/address-book/src/book/tests.rs

@@ -109,7 +109,7 @@ async fn add_new_peer_already_connected() {
             },
         ),
         Err(AddressBookError::PeerAlreadyConnected)
-    )
+    );
 }
 
 #[tokio::test]
@@ -143,5 +143,5 @@ async fn banned_peer_removed_from_peer_lists() {
             .unwrap()
             .into_inner(),
         TestNetZoneAddr(1)
-    )
+    );
 }

p2p/address-book/src/peer_list.rs

@@ -7,31 +7,31 @@ use cuprate_p2p_core::{services::ZoneSpecificPeerListEntryBase, NetZoneAddress,
 use cuprate_pruning::{PruningSeed, CRYPTONOTE_MAX_BLOCK_HEIGHT};
 
 #[cfg(test)]
-pub mod tests;
+pub(crate) mod tests;
 
 /// A Peer list in the address book.
 ///
 /// This could either be the white list or gray list.
 #[derive(Debug)]
-pub struct PeerList<Z: NetworkZone> {
+pub(crate) struct PeerList<Z: NetworkZone> {
     /// The peers with their peer data.
     pub peers: IndexMap<Z::Addr, ZoneSpecificPeerListEntryBase<Z::Addr>>,
     /// An index of Pruning seed to address, so can quickly grab peers with the blocks
     /// we want.
     ///
-    /// Pruning seeds are sorted by first their log_stripes and then their stripe.
+    /// Pruning seeds are sorted by first their `log_stripes` and then their stripe.
     /// This means the first peers in this list will store more blocks than peers
     /// later on. So when we need a peer with a certain block we look at the peers
     /// storing more blocks first then work our way to the peers storing less.
     ///  
     pruning_seeds: BTreeMap<PruningSeed, Vec<Z::Addr>>,
-    /// A hashmap linking ban_ids to addresses.
+    /// A hashmap linking `ban_ids` to addresses.
     ban_ids: HashMap<<Z::Addr as NetZoneAddress>::BanID, Vec<Z::Addr>>,
 }
 
 impl<Z: NetworkZone> PeerList<Z> {
     /// Creates a new peer list.
-    pub fn new(list: Vec<ZoneSpecificPeerListEntryBase<Z::Addr>>) -> PeerList<Z> {
+    pub(crate) fn new(list: Vec<ZoneSpecificPeerListEntryBase<Z::Addr>>) -> Self {
         let mut peers = IndexMap::with_capacity(list.len());
         let mut pruning_seeds = BTreeMap::new();
         let mut ban_ids = HashMap::with_capacity(list.len());
@@ -49,7 +49,7 @@ impl<Z: NetworkZone> PeerList<Z> {
 
             peers.insert(peer.adr, peer);
         }
-        PeerList {
+        Self {
             peers,
             pruning_seeds,
             ban_ids,
@@ -57,21 +57,20 @@ impl<Z: NetworkZone> PeerList<Z> {
     }
 
     /// Gets the length of the peer list
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         self.peers.len()
     }
 
     /// Adds a new peer to the peer list
-    pub fn add_new_peer(&mut self, peer: ZoneSpecificPeerListEntryBase<Z::Addr>) {
+    pub(crate) fn add_new_peer(&mut self, peer: ZoneSpecificPeerListEntryBase<Z::Addr>) {
         if self.peers.insert(peer.adr, peer).is_none() {
-            // It's more clear with this
+            #[expect(clippy::unwrap_or_default, reason = "It's more clear with this")]
-            #[allow(clippy::unwrap_or_default)]
             self.pruning_seeds
                 .entry(peer.pruning_seed)
                 .or_insert_with(Vec::new)
                 .push(peer.adr);
 
-            #[allow(clippy::unwrap_or_default)]
+            #[expect(clippy::unwrap_or_default)]
             self.ban_ids
                 .entry(peer.adr.ban_id())
                 .or_insert_with(Vec::new)
@@ -85,7 +84,7 @@ impl<Z: NetworkZone> PeerList<Z> {
     /// list.
     ///
     /// The given peer will be removed from the peer list.
-    pub fn take_random_peer<R: Rng>(
+    pub(crate) fn take_random_peer<R: Rng>(
         &mut self,
         r: &mut R,
         block_needed: Option<usize>,
@@ -127,7 +126,7 @@ impl<Z: NetworkZone> PeerList<Z> {
         None
     }
 
-    pub fn get_random_peers<R: Rng>(
+    pub(crate) fn get_random_peers<R: Rng>(
         &self,
         r: &mut R,
         len: usize,
@@ -142,7 +141,7 @@ impl<Z: NetworkZone> PeerList<Z> {
     }
 
     /// Returns a mutable reference to a peer.
-    pub fn get_peer_mut(
+    pub(crate) fn get_peer_mut(
         &mut self,
         peer: &Z::Addr,
     ) -> Option<&mut ZoneSpecificPeerListEntryBase<Z::Addr>> {
@@ -150,7 +149,7 @@ impl<Z: NetworkZone> PeerList<Z> {
     }
 
     /// Returns true if the list contains this peer.
-    pub fn contains_peer(&self, peer: &Z::Addr) -> bool {
+    pub(crate) fn contains_peer(&self, peer: &Z::Addr) -> bool {
         self.peers.contains_key(peer)
     }
 
@@ -189,11 +188,11 @@ impl<Z: NetworkZone> PeerList<Z> {
     /// MUST NOT BE USED ALONE
     fn remove_peer_from_all_idxs(&mut self, peer: &ZoneSpecificPeerListEntryBase<Z::Addr>) {
         self.remove_peer_pruning_idx(peer);
-        self.remove_peer_ban_idx(peer)
+        self.remove_peer_ban_idx(peer);
     }
 
     /// Removes a peer from the peer list
-    pub fn remove_peer(
+    pub(crate) fn remove_peer(
         &mut self,
         peer: &Z::Addr,
     ) -> Option<ZoneSpecificPeerListEntryBase<Z::Addr>> {
@@ -203,7 +202,7 @@ impl<Z: NetworkZone> PeerList<Z> {
     }
 
     /// Removes all peers with a specific ban id.
-    pub fn remove_peers_with_ban_id(&mut self, ban_id: &<Z::Addr as NetZoneAddress>::BanID) {
+    pub(crate) fn remove_peers_with_ban_id(&mut self, ban_id: &<Z::Addr as NetZoneAddress>::BanID) {
         let Some(addresses) = self.ban_ids.get(ban_id) else {
             // No peers to ban
             return;
@@ -217,8 +216,8 @@ impl<Z: NetworkZone> PeerList<Z> {
     /// Tries to reduce the peer list to `new_len`.
     ///
     /// This function could keep the list bigger than `new_len` if `must_keep_peers`s length
-    /// is larger than new_len, in that case we will remove as much as we can.
+    /// is larger than `new_len`, in that case we will remove as much as we can.
-    pub fn reduce_list(&mut self, must_keep_peers: &HashSet<Z::Addr>, new_len: usize) {
+    pub(crate) fn reduce_list(&mut self, must_keep_peers: &HashSet<Z::Addr>, new_len: usize) {
         if new_len >= self.len() {
             return;
         }

p2p/address-book/src/peer_list/tests.rs

@@ -14,7 +14,7 @@ fn make_fake_peer(
 ) -> ZoneSpecificPeerListEntryBase<TestNetZoneAddr> {
     ZoneSpecificPeerListEntryBase {
         adr: TestNetZoneAddr(id),
-        id: id as u64,
+        id: u64::from(id),
         last_seen: 0,
         pruning_seed: PruningSeed::decompress(pruning_seed.unwrap_or(0)).unwrap(),
         rpc_port: 0,
@@ -22,14 +22,14 @@ fn make_fake_peer(
     }
 }
 
-pub fn make_fake_peer_list(
+pub(crate) fn make_fake_peer_list(
     start_idx: u32,
     numb_o_peers: u32,
 ) -> PeerList<TestNetZone<true, true, true>> {
     let mut peer_list = Vec::with_capacity(numb_o_peers as usize);
 
     for idx in start_idx..(start_idx + numb_o_peers) {
-        peer_list.push(make_fake_peer(idx, None))
+        peer_list.push(make_fake_peer(idx, None));
     }
 
     PeerList::new(peer_list)
@@ -50,7 +50,7 @@ fn make_fake_peer_list_with_random_pruning_seeds(
             } else {
                 r.gen_range(384..=391)
             }),
-        ))
+        ));
     }
     PeerList::new(peer_list)
 }
@@ -70,7 +70,7 @@ fn peer_list_reduce_length() {
 #[test]
 fn peer_list_reduce_length_with_peers_we_need() {
     let mut peer_list = make_fake_peer_list(0, 500);
-    let must_keep_peers = HashSet::from_iter(peer_list.peers.keys().copied());
+    let must_keep_peers = peer_list.peers.keys().copied().collect::<HashSet<_>>();
 
     let target_len = 49;
 
@@ -92,7 +92,7 @@ fn peer_list_remove_specific_peer() {
     let peers = peer_list.peers;
 
     for (_, addrs) in pruning_idxs {
-        addrs.iter().for_each(|adr| assert_ne!(adr, &peer.adr))
+        addrs.iter().for_each(|adr| assert_ne!(adr, &peer.adr));
     }
 
     assert!(!peers.contains_key(&peer.adr));
@@ -104,13 +104,13 @@ fn peer_list_pruning_idxs_are_correct() {
     let mut total_len = 0;
 
     for (seed, list) in peer_list.pruning_seeds {
-        for peer in list.iter() {
+        for peer in &list {
             assert_eq!(peer_list.peers.get(peer).unwrap().pruning_seed, seed);
             total_len += 1;
         }
     }
 
-    assert_eq!(total_len, peer_list.peers.len())
+    assert_eq!(total_len, peer_list.peers.len());
 }
 
 #[test]
@@ -122,11 +122,7 @@ fn peer_list_add_new_peer() {
 
     assert_eq!(peer_list.len(), 11);
     assert_eq!(peer_list.peers.get(&new_peer.adr), Some(&new_peer));
-    assert!(peer_list
+    assert!(peer_list.pruning_seeds[&new_peer.pruning_seed].contains(&new_peer.adr));
-        .pruning_seeds
-        .get(&new_peer.pruning_seed)
-        .unwrap()
-        .contains(&new_peer.adr));
 }
 
 #[test]
@@ -164,7 +160,7 @@ fn peer_list_get_peer_with_block() {
     assert!(peer
         .pruning_seed
         .get_next_unpruned_block(1, 1_000_000)
-        .is_ok())
+        .is_ok());
 }
 
 #[test]

p2p/address-book/src/store.rs

@@ -1,3 +1,8 @@
+#![expect(
+    single_use_lifetimes,
+    reason = "false positive on generated derive code on `SerPeerDataV1`"
+)]
+
 use std::fs;
 
 use borsh::{from_slice, to_vec, BorshDeserialize, BorshSerialize};
@@ -21,7 +26,7 @@ struct DeserPeerDataV1<A: NetZoneAddress> {
     gray_list: Vec<ZoneSpecificPeerListEntryBase<A>>,
 }
 
-pub fn save_peers_to_disk<Z: BorshNetworkZone>(
+pub(crate) fn save_peers_to_disk<Z: BorshNetworkZone>(
     cfg: &AddressBookConfig,
     white_list: &PeerList<Z>,
     gray_list: &PeerList<Z>,
@@ -38,7 +43,7 @@ pub fn save_peers_to_disk<Z: BorshNetworkZone>(
     spawn_blocking(move || fs::write(&file, &data))
 }
 
-pub async fn read_peers_from_disk<Z: BorshNetworkZone>(
+pub(crate) async fn read_peers_from_disk<Z: BorshNetworkZone>(
     cfg: &AddressBookConfig,
 ) -> Result<
     (

pruning/Cargo.toml

@@ -13,3 +13,6 @@ borsh = ["dep:borsh"]
 thiserror = { workspace = true }
 
 borsh = { workspace = true, features = ["derive", "std"], optional = true }
+
+[lints]
+workspace = true

pruning/src/lib.rs

@@ -71,7 +71,7 @@ impl PruningSeed {
     ///
     /// See: [`DecompressedPruningSeed::new`]
     pub fn new_pruned(stripe: u32, log_stripes: u32) -> Result<Self, PruningError> {
-        Ok(PruningSeed::Pruned(DecompressedPruningSeed::new(
+        Ok(Self::Pruned(DecompressedPruningSeed::new(
             stripe,
             log_stripes,
         )?))
@@ -81,9 +81,7 @@ impl PruningSeed {
     ///
     /// An error means the pruning seed was invalid.
     pub fn decompress(seed: u32) -> Result<Self, PruningError> {
-        Ok(DecompressedPruningSeed::decompress(seed)?
+        Ok(DecompressedPruningSeed::decompress(seed)?.map_or(Self::NotPruned, Self::Pruned))
-            .map(PruningSeed::Pruned)
-            .unwrap_or(PruningSeed::NotPruned))
     }
 
     /// Decompresses the seed, performing the same checks as [`PruningSeed::decompress`] and some more according to
@@ -103,34 +101,34 @@ impl PruningSeed {
     }
 
     /// Compresses this pruning seed to a u32.
-    pub fn compress(&self) -> u32 {
+    pub const fn compress(&self) -> u32 {
         match self {
-            PruningSeed::NotPruned => 0,
+            Self::NotPruned => 0,
-            PruningSeed::Pruned(seed) => seed.compress(),
+            Self::Pruned(seed) => seed.compress(),
         }
     }
 
     /// Returns the `log_stripes` for this seed, if this seed is pruned otherwise [`None`] is returned.
-    pub fn get_log_stripes(&self) -> Option<u32> {
+    pub const fn get_log_stripes(&self) -> Option<u32> {
         match self {
-            PruningSeed::NotPruned => None,
+            Self::NotPruned => None,
-            PruningSeed::Pruned(seed) => Some(seed.log_stripes),
+            Self::Pruned(seed) => Some(seed.log_stripes),
         }
     }
 
     /// Returns the `stripe` for this seed, if this seed is pruned otherwise [`None`] is returned.
-    pub fn get_stripe(&self) -> Option<u32> {
+    pub const fn get_stripe(&self) -> Option<u32> {
         match self {
-            PruningSeed::NotPruned => None,
+            Self::NotPruned => None,
-            PruningSeed::Pruned(seed) => Some(seed.stripe),
+            Self::Pruned(seed) => Some(seed.stripe),
         }
     }
 
     /// Returns `true` if a peer with this pruning seed should have a non-pruned version of a block.
-    pub fn has_full_block(&self, height: usize, blockchain_height: usize) -> bool {
+    pub const fn has_full_block(&self, height: usize, blockchain_height: usize) -> bool {
         match self {
-            PruningSeed::NotPruned => true,
+            Self::NotPruned => true,
-            PruningSeed::Pruned(seed) => seed.has_full_block(height, blockchain_height),
+            Self::Pruned(seed) => seed.has_full_block(height, blockchain_height),
         }
     }
 
@@ -155,10 +153,8 @@ impl PruningSeed {
         blockchain_height: usize,
     ) -> Result<Option<usize>, PruningError> {
         Ok(match self {
-            PruningSeed::NotPruned => None,
+            Self::NotPruned => None,
-            PruningSeed::Pruned(seed) => {
+            Self::Pruned(seed) => seed.get_next_pruned_block(block_height, blockchain_height)?,
-                seed.get_next_pruned_block(block_height, blockchain_height)?
-            }
         })
     }
 
@@ -181,10 +177,8 @@ impl PruningSeed {
         blockchain_height: usize,
     ) -> Result<usize, PruningError> {
         Ok(match self {
-            PruningSeed::NotPruned => block_height,
+            Self::NotPruned => block_height,
-            PruningSeed::Pruned(seed) => {
+            Self::Pruned(seed) => seed.get_next_unpruned_block(block_height, blockchain_height)?,
-                seed.get_next_unpruned_block(block_height, blockchain_height)?
-            }
         })
     }
 }
@@ -199,11 +193,11 @@ impl Ord for PruningSeed {
     fn cmp(&self, other: &Self) -> Ordering {
         match (self, other) {
             // Make sure pruning seeds storing more blocks are greater.
-            (PruningSeed::NotPruned, PruningSeed::NotPruned) => Ordering::Equal,
+            (Self::NotPruned, Self::NotPruned) => Ordering::Equal,
-            (PruningSeed::NotPruned, PruningSeed::Pruned(_)) => Ordering::Greater,
+            (Self::NotPruned, Self::Pruned(_)) => Ordering::Greater,
-            (PruningSeed::Pruned(_), PruningSeed::NotPruned) => Ordering::Less,
+            (Self::Pruned(_), Self::NotPruned) => Ordering::Less,
 
-            (PruningSeed::Pruned(seed1), PruningSeed::Pruned(seed2)) => seed1.cmp(seed2),
+            (Self::Pruned(seed1), Self::Pruned(seed2)) => seed1.cmp(seed2),
         }
     }
 }
@@ -222,7 +216,7 @@ pub struct DecompressedPruningSeed {
     log_stripes: u32,
     /// The specific portion this peer keeps.
     ///
-    /// *MUST* be between 1..=2^log_stripes
+    /// *MUST* be between `1..=2^log_stripes`
     stripe: u32,
 }
 
@@ -268,13 +262,13 @@ impl DecompressedPruningSeed {
     /// a valid seed you currently MUST pass in a number 1 to 8 for `stripe`
     /// and 3 for `log_stripes`.*
     ///
-    pub fn new(stripe: u32, log_stripes: u32) -> Result<Self, PruningError> {
+    pub const fn new(stripe: u32, log_stripes: u32) -> Result<Self, PruningError> {
         if log_stripes > PRUNING_SEED_LOG_STRIPES_MASK {
             Err(PruningError::LogStripesOutOfRange)
         } else if !(stripe > 0 && stripe <= (1 << log_stripes)) {
             Err(PruningError::StripeOutOfRange)
         } else {
-            Ok(DecompressedPruningSeed {
+            Ok(Self {
                 log_stripes,
                 stripe,
             })
@@ -286,7 +280,7 @@ impl DecompressedPruningSeed {
     /// Will return Ok(None) if the pruning seed means no pruning.
     ///
     /// An error means the pruning seed was invalid.
-    pub fn decompress(seed: u32) -> Result<Option<Self>, PruningError> {
+    pub const fn decompress(seed: u32) -> Result<Option<Self>, PruningError> {
         if seed == 0 {
             // No pruning.
             return Ok(None);
@@ -299,20 +293,20 @@ impl DecompressedPruningSeed {
             return Err(PruningError::StripeOutOfRange);
         }
 
-        Ok(Some(DecompressedPruningSeed {
+        Ok(Some(Self {
             log_stripes,
             stripe,
         }))
     }
 
     /// Compresses the pruning seed into a u32.
-    pub fn compress(&self) -> u32 {
+    pub const fn compress(&self) -> u32 {
         (self.log_stripes << PRUNING_SEED_LOG_STRIPES_SHIFT)
             | ((self.stripe - 1) << PRUNING_SEED_STRIPE_SHIFT)
     }
 
     /// Returns `true` if a peer with this pruning seed should have a non-pruned version of a block.
-    pub fn has_full_block(&self, height: usize, blockchain_height: usize) -> bool {
+    pub const fn has_full_block(&self, height: usize, blockchain_height: usize) -> bool {
         match get_block_pruning_stripe(height, blockchain_height, self.log_stripes) {
             Some(block_stripe) => self.stripe == block_stripe,
             None => true,
@@ -419,7 +413,7 @@ impl DecompressedPruningSeed {
         // We can get the end of our "non-pruning" cycle by getting the next stripe's first un-pruned block height.
         // So we calculate the next un-pruned block for the next stripe and return it as our next pruned block
         let next_stripe = 1 + (self.stripe & ((1 << self.log_stripes) - 1));
-        let seed = DecompressedPruningSeed::new(next_stripe, self.log_stripes)
+        let seed = Self::new(next_stripe, self.log_stripes)
             .expect("We just made sure this stripe is in range for this log_stripe");
 
         let calculated_height = seed.get_next_unpruned_block(block_height, blockchain_height)?;
@@ -433,7 +427,7 @@ impl DecompressedPruningSeed {
     }
 }
 
-fn get_block_pruning_stripe(
+const fn get_block_pruning_stripe(
     block_height: usize,
     blockchain_height: usize,
     log_stripe: u32,
@@ -441,9 +435,14 @@ fn get_block_pruning_stripe(
     if block_height + CRYPTONOTE_PRUNING_TIP_BLOCKS >= blockchain_height {
         None
     } else {
+        #[expect(
+            clippy::cast_possible_truncation,
+            clippy::cast_sign_loss,
+            reason = "it's trivial to prove it's ok to us `as` here"
+        )]
         Some(
             (((block_height / CRYPTONOTE_PRUNING_STRIPE_SIZE) & ((1 << log_stripe) as usize - 1))
-                + 1) as u32, // it's trivial to prove it's ok to us `as` here
+                + 1) as u32,
         )
     }
 }
@@ -483,16 +482,17 @@ mod tests {
     #[test]
     fn get_pruning_log_stripe() {
         let all_valid_seeds = make_all_pruning_seeds();
-        for seed in all_valid_seeds.iter() {
+        for seed in &all_valid_seeds {
-            assert_eq!(seed.get_log_stripes().unwrap(), 3)
+            assert_eq!(seed.get_log_stripes().unwrap(), 3);
         }
     }
 
     #[test]
     fn get_pruning_stripe() {
         let all_valid_seeds = make_all_pruning_seeds();
+        #[expect(clippy::cast_possible_truncation)]
         for (i, seed) in all_valid_seeds.iter().enumerate() {
-            assert_eq!(seed.get_stripe().unwrap(), i as u32 + 1)
+            assert_eq!(seed.get_stripe().unwrap(), i as u32 + 1);
         }
     }
 
@@ -554,7 +554,7 @@ mod tests {
             assert_eq!(
                 seed.get_next_unpruned_block(0, blockchain_height).unwrap(),
                 i * 4096
-            )
+            );
         }
 
         for (i, seed) in all_valid_seeds.iter().enumerate() {
@@ -562,7 +562,7 @@ mod tests {
                 seed.get_next_unpruned_block((i + 1) * 4096, blockchain_height)
                     .unwrap(),
                 i * 4096 + 32768
-            )
+            );
         }
 
         for (i, seed) in all_valid_seeds.iter().enumerate() {
@@ -570,15 +570,15 @@ mod tests {
                 seed.get_next_unpruned_block((i + 8) * 4096, blockchain_height)
                     .unwrap(),
                 i * 4096 + 32768
-            )
+            );
         }
 
-        for seed in all_valid_seeds.iter() {
+        for seed in &all_valid_seeds {
             assert_eq!(
                 seed.get_next_unpruned_block(76437863 - 1, blockchain_height)
                     .unwrap(),
                 76437863 - 1
-            )
+            );
         }
 
         let zero_seed = PruningSeed::NotPruned;
@@ -591,7 +591,7 @@ mod tests {
         let seed = PruningSeed::decompress(384).unwrap();
 
         // the next unpruned block is the first tip block
-        assert_eq!(seed.get_next_unpruned_block(5000, 11000).unwrap(), 5500)
+        assert_eq!(seed.get_next_unpruned_block(5000, 11000).unwrap(), 5500);
     }
 
     #[test]
@@ -605,7 +605,7 @@ mod tests {
                     .unwrap()
                     .unwrap(),
                 0
-            )
+            );
         }
 
         for (i, seed) in all_valid_seeds.iter().enumerate() {
@@ -614,7 +614,7 @@ mod tests {
                     .unwrap()
                     .unwrap(),
                 (i + 1) * 4096
-            )
+            );
         }
 
         for (i, seed) in all_valid_seeds.iter().enumerate() {
@@ -623,15 +623,15 @@ mod tests {
                     .unwrap()
                     .unwrap(),
                 (i + 9) * 4096
-            )
+            );
         }
 
-        for seed in all_valid_seeds.iter() {
+        for seed in &all_valid_seeds {
             assert_eq!(
                 seed.get_next_pruned_block(76437863 - 1, blockchain_height)
                     .unwrap(),
                 None
-            )
+            );
         }
 
         let zero_seed = PruningSeed::NotPruned;
@@ -644,6 +644,6 @@ mod tests {
         let seed = PruningSeed::decompress(384).unwrap();
 
         // there is no next pruned block
-        assert_eq!(seed.get_next_pruned_block(5000, 10000).unwrap(), None)
+        assert_eq!(seed.get_next_pruned_block(5000, 10000).unwrap(), None);
     }
 }

storage/blockchain/Cargo.toml

@@ -15,21 +15,19 @@ default     = ["heed", "service"]
 heed        = ["cuprate-database/heed"]
 redb        = ["cuprate-database/redb"]
 redb-memory = ["cuprate-database/redb-memory"]
-service     = ["dep:thread_local", "dep:rayon"]
+service     = ["dep:thread_local", "dep:rayon", "cuprate-helper/thread"]
 
 [dependencies]
-# FIXME:
-# We only need the `thread` feature if `service` is enabled.
-# Figure out how to enable features of an already pulled in dependency conditionally.
 cuprate-database         = { path = "../database" }
 cuprate-database-service = { path = "../service" }
-cuprate-helper           = { path = "../../helper", features = ["fs", "thread", "map"] }
+cuprate-helper           = { path = "../../helper", features = ["fs", "map"] }
 cuprate-types            = { path = "../../types", features = ["blockchain"] }
+cuprate-pruning          = { path = "../../pruning" }
 
 bitflags         = { workspace = true, features = ["std", "serde", "bytemuck"] }
 bytemuck         = { workspace = true, features = ["must_cast", "derive", "min_const_generics", "extern_crate_alloc"] }
 curve25519-dalek = { workspace = true }
-cuprate-pruning  = { path = "../../pruning" }
+rand             = { workspace = true }
 monero-serai     = { workspace = true, features = ["std"] }
 serde            = { workspace = true, optional = true }
 

storage/blockchain/src/ops/alt_block/block.rs

@@ -0,0 +1,337 @@
+use bytemuck::TransparentWrapper;
+use monero_serai::block::{Block, BlockHeader};
+
+use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError, StorableVec};
+use cuprate_helper::map::{combine_low_high_bits_to_u128, split_u128_into_low_high_bits};
+use cuprate_types::{AltBlockInformation, Chain, ChainId, ExtendedBlockHeader, HardFork};
+
+use crate::{
+    ops::{
+        alt_block::{add_alt_transaction_blob, get_alt_transaction, update_alt_chain_info},
+        block::get_block_info,
+        macros::doc_error,
+    },
+    tables::{Tables, TablesMut},
+    types::{AltBlockHeight, BlockHash, BlockHeight, CompactAltBlockInfo},
+};
+
+/// Flush all alt-block data from all the alt-block tables.
+///
+/// This function completely empties the alt block tables.
+pub fn flush_alt_blocks<'a, E: cuprate_database::EnvInner<'a>>(
+    env_inner: &E,
+    tx_rw: &mut E::Rw<'_>,
+) -> Result<(), RuntimeError> {
+    use crate::tables::{
+        AltBlockBlobs, AltBlockHeights, AltBlocksInfo, AltChainInfos, AltTransactionBlobs,
+        AltTransactionInfos,
+    };
+
+    env_inner.clear_db::<AltChainInfos>(tx_rw)?;
+    env_inner.clear_db::<AltBlockHeights>(tx_rw)?;
+    env_inner.clear_db::<AltBlocksInfo>(tx_rw)?;
+    env_inner.clear_db::<AltBlockBlobs>(tx_rw)?;
+    env_inner.clear_db::<AltTransactionBlobs>(tx_rw)?;
+    env_inner.clear_db::<AltTransactionInfos>(tx_rw)
+}
+
+/// Add a [`AltBlockInformation`] to the database.
+///
+/// This extracts all the data from the input block and
+/// maps/adds them to the appropriate database tables.
+///
+#[doc = doc_error!()]
+///
+/// # Panics
+/// This function will panic if:
+/// - `alt_block.height` is == `0`
+/// - `alt_block.txs.len()` != `alt_block.block.transactions.len()`
+///
+pub fn add_alt_block(
+    alt_block: &AltBlockInformation,
+    tables: &mut impl TablesMut,
+) -> Result<(), RuntimeError> {
+    let alt_block_height = AltBlockHeight {
+        chain_id: alt_block.chain_id.into(),
+        height: alt_block.height,
+    };
+
+    tables
+        .alt_block_heights_mut()
+        .put(&alt_block.block_hash, &alt_block_height)?;
+
+    update_alt_chain_info(&alt_block_height, &alt_block.block.header.previous, tables)?;
+
+    let (cumulative_difficulty_low, cumulative_difficulty_high) =
+        split_u128_into_low_high_bits(alt_block.cumulative_difficulty);
+
+    let alt_block_info = CompactAltBlockInfo {
+        block_hash: alt_block.block_hash,
+        pow_hash: alt_block.pow_hash,
+        height: alt_block.height,
+        weight: alt_block.weight,
+        long_term_weight: alt_block.long_term_weight,
+        cumulative_difficulty_low,
+        cumulative_difficulty_high,
+    };
+
+    tables
+        .alt_blocks_info_mut()
+        .put(&alt_block_height, &alt_block_info)?;
+
+    tables.alt_block_blobs_mut().put(
+        &alt_block_height,
+        StorableVec::wrap_ref(&alt_block.block_blob),
+    )?;
+
+    assert_eq!(alt_block.txs.len(), alt_block.block.transactions.len());
+    for tx in &alt_block.txs {
+        add_alt_transaction_blob(tx, tables)?;
+    }
+
+    Ok(())
+}
+
+/// Retrieves an [`AltBlockInformation`] from the database.
+///
+/// This function will look at only the blocks with the given [`AltBlockHeight::chain_id`], no others
+/// even if they are technically part of this chain.
+#[doc = doc_error!()]
+pub fn get_alt_block(
+    alt_block_height: &AltBlockHeight,
+    tables: &impl Tables,
+) -> Result<AltBlockInformation, RuntimeError> {
+    let block_info = tables.alt_blocks_info().get(alt_block_height)?;
+
+    let block_blob = tables.alt_block_blobs().get(alt_block_height)?.0;
+
+    let block = Block::read(&mut block_blob.as_slice())?;
+
+    let txs = block
+        .transactions
+        .iter()
+        .map(|tx_hash| get_alt_transaction(tx_hash, tables))
+        .collect::<Result<_, RuntimeError>>()?;
+
+    Ok(AltBlockInformation {
+        block,
+        block_blob,
+        txs,
+        block_hash: block_info.block_hash,
+        pow_hash: block_info.pow_hash,
+        height: block_info.height,
+        weight: block_info.weight,
+        long_term_weight: block_info.long_term_weight,
+        cumulative_difficulty: combine_low_high_bits_to_u128(
+            block_info.cumulative_difficulty_low,
+            block_info.cumulative_difficulty_high,
+        ),
+        chain_id: alt_block_height.chain_id.into(),
+    })
+}
+
+/// Retrieves the hash of the block at the given `block_height` on the alt chain with
+/// the given [`ChainId`].
+///
+/// This function will get blocks from the whole chain, for example if you were to ask for height
+/// `0` with any [`ChainId`] (as long that chain actually exists) you will get the main chain genesis.
+///
+#[doc = doc_error!()]
+pub fn get_alt_block_hash(
+    block_height: &BlockHeight,
+    alt_chain: ChainId,
+    tables: &impl Tables,
+) -> Result<BlockHash, RuntimeError> {
+    let alt_chains = tables.alt_chain_infos();
+
+    // First find what [`ChainId`] this block would be stored under.
+    let original_chain = {
+        let mut chain = alt_chain.into();
+        loop {
+            let chain_info = alt_chains.get(&chain)?;
+
+            if chain_info.common_ancestor_height < *block_height {
+                break Chain::Alt(chain.into());
+            }
+
+            match chain_info.parent_chain.into() {
+                Chain::Main => break Chain::Main,
+                Chain::Alt(alt_chain_id) => {
+                    chain = alt_chain_id.into();
+                    continue;
+                }
+            }
+        }
+    };
+
+    // Get the block hash.
+    match original_chain {
+        Chain::Main => {
+            get_block_info(block_height, tables.block_infos()).map(|info| info.block_hash)
+        }
+        Chain::Alt(chain_id) => tables
+            .alt_blocks_info()
+            .get(&AltBlockHeight {
+                chain_id: chain_id.into(),
+                height: *block_height,
+            })
+            .map(|info| info.block_hash),
+    }
+}
+
+/// Retrieves the [`ExtendedBlockHeader`] of the alt-block with an exact [`AltBlockHeight`].
+///
+/// This function will look at only the blocks with the given [`AltBlockHeight::chain_id`], no others
+/// even if they are technically part of this chain.
+///
+#[doc = doc_error!()]
+pub fn get_alt_block_extended_header_from_height(
+    height: &AltBlockHeight,
+    table: &impl Tables,
+) -> Result<ExtendedBlockHeader, RuntimeError> {
+    let block_info = table.alt_blocks_info().get(height)?;
+
+    let block_blob = table.alt_block_blobs().get(height)?.0;
+
+    let block_header = BlockHeader::read(&mut block_blob.as_slice())?;
+
+    Ok(ExtendedBlockHeader {
+        version: HardFork::from_version(block_header.hardfork_version)
+            .expect("Block in DB must have correct version"),
+        vote: block_header.hardfork_version,
+        timestamp: block_header.timestamp,
+        cumulative_difficulty: combine_low_high_bits_to_u128(
+            block_info.cumulative_difficulty_low,
+            block_info.cumulative_difficulty_high,
+        ),
+        block_weight: block_info.weight,
+        long_term_weight: block_info.long_term_weight,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::num::NonZero;
+
+    use cuprate_database::{Env, EnvInner, TxRw};
+    use cuprate_test_utils::data::{BLOCK_V16_TX0, BLOCK_V1_TX2, BLOCK_V9_TX3};
+    use cuprate_types::{Chain, ChainId};
+
+    use crate::{
+        ops::{
+            alt_block::{
+                add_alt_block, flush_alt_blocks, get_alt_block,
+                get_alt_block_extended_header_from_height, get_alt_block_hash,
+                get_alt_chain_history_ranges,
+            },
+            block::{add_block, pop_block},
+        },
+        tables::{OpenTables, Tables},
+        tests::{assert_all_tables_are_empty, map_verified_block_to_alt, tmp_concrete_env},
+        types::AltBlockHeight,
+    };
+
+    #[expect(clippy::range_plus_one)]
+    #[test]
+    fn all_alt_blocks() {
+        let (env, _tmp) = tmp_concrete_env();
+        let env_inner = env.env_inner();
+        assert_all_tables_are_empty(&env);
+
+        let chain_id = ChainId(NonZero::new(1).unwrap());
+
+        // Add initial block.
+        {
+            let tx_rw = env_inner.tx_rw().unwrap();
+            let mut tables = env_inner.open_tables_mut(&tx_rw).unwrap();
+
+            let mut initial_block = BLOCK_V1_TX2.clone();
+            initial_block.height = 0;
+
+            add_block(&initial_block, &mut tables).unwrap();
+
+            drop(tables);
+            TxRw::commit(tx_rw).unwrap();
+        }
+
+        let alt_blocks = [
+            map_verified_block_to_alt(BLOCK_V9_TX3.clone(), chain_id),
+            map_verified_block_to_alt(BLOCK_V16_TX0.clone(), chain_id),
+        ];
+
+        // Add alt-blocks
+        {
+            let tx_rw = env_inner.tx_rw().unwrap();
+            let mut tables = env_inner.open_tables_mut(&tx_rw).unwrap();
+
+            let mut prev_hash = BLOCK_V1_TX2.block_hash;
+            for (i, mut alt_block) in alt_blocks.into_iter().enumerate() {
+                let height = i + 1;
+
+                alt_block.height = height;
+                alt_block.block.header.previous = prev_hash;
+                alt_block.block_blob = alt_block.block.serialize();
+
+                add_alt_block(&alt_block, &mut tables).unwrap();
+
+                let alt_height = AltBlockHeight {
+                    chain_id: chain_id.into(),
+                    height,
+                };
+
+                let alt_block_2 = get_alt_block(&alt_height, &tables).unwrap();
+                assert_eq!(alt_block.block, alt_block_2.block);
+
+                let headers = get_alt_chain_history_ranges(
+                    0..(height + 1),
+                    chain_id,
+                    tables.alt_chain_infos(),
+                )
+                .unwrap();
+
+                assert_eq!(headers.len(), 2);
+                assert_eq!(headers[1], (Chain::Main, 0..1));
+                assert_eq!(headers[0], (Chain::Alt(chain_id), 1..(height + 1)));
+
+                prev_hash = alt_block.block_hash;
+
+                let header =
+                    get_alt_block_extended_header_from_height(&alt_height, &tables).unwrap();
+
+                assert_eq!(header.timestamp, alt_block.block.header.timestamp);
+                assert_eq!(header.block_weight, alt_block.weight);
+                assert_eq!(header.long_term_weight, alt_block.long_term_weight);
+                assert_eq!(
+                    header.cumulative_difficulty,
+                    alt_block.cumulative_difficulty
+                );
+                assert_eq!(
+                    header.version.as_u8(),
+                    alt_block.block.header.hardfork_version
+                );
+                assert_eq!(header.vote, alt_block.block.header.hardfork_signal);
+
+                let block_hash = get_alt_block_hash(&height, chain_id, &tables).unwrap();
+
+                assert_eq!(block_hash, alt_block.block_hash);
+            }
+
+            drop(tables);
+            TxRw::commit(tx_rw).unwrap();
+        }
+
+        {
+            let mut tx_rw = env_inner.tx_rw().unwrap();
+
+            flush_alt_blocks(&env_inner, &mut tx_rw).unwrap();
+
+            let mut tables = env_inner.open_tables_mut(&tx_rw).unwrap();
+            pop_block(None, &mut tables).unwrap();
+
+            drop(tables);
+            TxRw::commit(tx_rw).unwrap();
+        }
+
+        assert_all_tables_are_empty(&env);
+    }
+}

storage/blockchain/src/ops/alt_block/chain.rs

@@ -0,0 +1,117 @@
+use std::cmp::{max, min};
+
+use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError};
+use cuprate_types::{Chain, ChainId};
+
+use crate::{
+    ops::macros::{doc_add_alt_block_inner_invariant, doc_error},
+    tables::{AltChainInfos, TablesMut},
+    types::{AltBlockHeight, AltChainInfo, BlockHash, BlockHeight},
+};
+
+/// Updates the [`AltChainInfo`] with information on a new alt-block.
+///
+#[doc = doc_add_alt_block_inner_invariant!()]
+#[doc = doc_error!()]
+///
+/// # Panics
+///
+/// This will panic if [`AltBlockHeight::height`] == `0`.
+pub fn update_alt_chain_info(
+    alt_block_height: &AltBlockHeight,
+    prev_hash: &BlockHash,
+    tables: &mut impl TablesMut,
+) -> Result<(), RuntimeError> {
+    let parent_chain = match tables.alt_block_heights().get(prev_hash) {
+        Ok(alt_parent_height) => Chain::Alt(alt_parent_height.chain_id.into()),
+        Err(RuntimeError::KeyNotFound) => Chain::Main,
+        Err(e) => return Err(e),
+    };
+
+    // try update the info if one exists for this chain.
+    let update = tables
+        .alt_chain_infos_mut()
+        .update(&alt_block_height.chain_id, |mut info| {
+            if info.chain_height < alt_block_height.height + 1 {
+                // If the chain height is increasing we only need to update the chain height.
+                info.chain_height = alt_block_height.height + 1;
+            } else {
+                // If the chain height is not increasing we are popping blocks and need to update the
+                // split point.
+                info.common_ancestor_height = alt_block_height.height.checked_sub(1).unwrap();
+                info.parent_chain = parent_chain.into();
+            }
+
+            info.chain_height = alt_block_height.height + 1;
+            Some(info)
+        });
+
+    match update {
+        Ok(()) => return Ok(()),
+        Err(RuntimeError::KeyNotFound) => (),
+        Err(e) => return Err(e),
+    }
+
+    // If one doesn't already exist add it.
+
+    tables.alt_chain_infos_mut().put(
+        &alt_block_height.chain_id,
+        &AltChainInfo {
+            parent_chain: parent_chain.into(),
+            common_ancestor_height: alt_block_height.height.checked_sub(1).unwrap(),
+            chain_height: alt_block_height.height + 1,
+        },
+    )
+}
+
+/// Get the height history of an alt-chain in reverse chronological order.
+///
+/// Height history is a list of height ranges with the corresponding [`Chain`] they are stored under.
+/// For example if your range goes from height `0` the last entry in the list will be [`Chain::Main`]
+/// upto the height where the first split occurs.
+#[doc = doc_error!()]
+pub fn get_alt_chain_history_ranges(
+    range: std::ops::Range<BlockHeight>,
+    alt_chain: ChainId,
+    alt_chain_infos: &impl DatabaseRo<AltChainInfos>,
+) -> Result<Vec<(Chain, std::ops::Range<BlockHeight>)>, RuntimeError> {
+    let mut ranges = Vec::with_capacity(5);
+
+    let mut i = range.end;
+    let mut current_chain_id = alt_chain.into();
+    while i > range.start {
+        let chain_info = alt_chain_infos.get(&current_chain_id)?;
+
+        let start_height = max(range.start, chain_info.common_ancestor_height + 1);
+        let end_height = min(i, chain_info.chain_height);
+
+        ranges.push((
+            Chain::Alt(current_chain_id.into()),
+            start_height..end_height,
+        ));
+        i = chain_info.common_ancestor_height + 1;
+
+        match chain_info.parent_chain.into() {
+            Chain::Main => {
+                ranges.push((Chain::Main, range.start..i));
+                break;
+            }
+            Chain::Alt(alt_chain_id) => {
+                let alt_chain_id = alt_chain_id.into();
+
+                // This shouldn't be possible to hit, however in a test with custom (invalid) block data
+                // this caused an infinite loop.
+                if alt_chain_id == current_chain_id {
+                    return Err(RuntimeError::Io(std::io::Error::other(
+                        "Loop detected in ChainIDs, invalid alt chain.",
+                    )));
+                }
+
+                current_chain_id = alt_chain_id;
+                continue;
+            }
+        }
+    }
+
+    Ok(ranges)
+}

storage/blockchain/src/ops/alt_block/mod.rs

@@ -0,0 +1,58 @@
+//! Alternative Block/Chain Ops
+//!
+//! Alternative chains are chains that potentially have more proof-of-work than the main-chain
+//! which we are tracking to potentially re-org to.
+//!
+//! Cuprate uses an ID system for alt-chains. When a split is made from the main-chain we generate
+//! a random [`ChainID`](cuprate_types::ChainId) and assign it to the chain:
+//!
+//! ```text
+//!      |
+//!      |
+//!      |   split
+//!      |-------------
+//!      |            |
+//!      |            |
+//!     \|/          \|/
+//!  main-chain    ChainID(X)
+//! ```
+//!
+//! In that example if we were to receive an alt-block which immediately follows the top block of `ChainID(X)`
+//! then that block will also be stored under `ChainID(X)`. However, if it follows from another block from `ChainID(X)`
+//! we will split into a chain with a different ID:
+//!
+//! ```text
+//!      |
+//!      |
+//!      |   split
+//!      |-------------
+//!      |            |   split
+//!      |            |-------------|
+//!      |            |             |
+//!      |            |             |
+//!      |            |             |
+//!     \|/          \|/           \|/
+//!  main-chain    ChainID(X)    ChainID(Z)
+//! ```
+//!
+//! As you can see if we wanted to get all the alt-blocks in `ChainID(Z)` that now includes some blocks from `ChainID(X)` as well.
+//! [`get_alt_chain_history_ranges`] covers this and is the method to get the ranges of heights needed from each [`ChainID`](cuprate_types::ChainId)
+//! to get all the alt-blocks in a given [`ChainID`](cuprate_types::ChainId).
+//!
+//! Although this should be kept in mind as a possibility, because Cuprate's block downloader will only track a single chain it is
+//! unlikely that we will be tracking [`ChainID`](cuprate_types::ChainId)s that don't immediately connect to the main-chain.
+//!
+//! ## Why not use the block's `previous` field?
+//!
+//! Although that would be easier, it makes getting a range of block extremely slow, as we have to build the weight cache to verify
+//! blocks, roughly 100,000 block headers needed, this cost is too high.
+mod block;
+mod chain;
+mod tx;
+
+pub use block::{
+    add_alt_block, flush_alt_blocks, get_alt_block, get_alt_block_extended_header_from_height,
+    get_alt_block_hash,
+};
+pub use chain::{get_alt_chain_history_ranges, update_alt_chain_info};
+pub use tx::{add_alt_transaction_blob, get_alt_transaction};

storage/blockchain/src/ops/alt_block/tx.rs

@@ -0,0 +1,76 @@
+use bytemuck::TransparentWrapper;
+use monero_serai::transaction::Transaction;
+
+use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError, StorableVec};
+use cuprate_types::VerifiedTransactionInformation;
+
+use crate::{
+    ops::macros::{doc_add_alt_block_inner_invariant, doc_error},
+    tables::{Tables, TablesMut},
+    types::{AltTransactionInfo, TxHash},
+};
+
+/// Adds a [`VerifiedTransactionInformation`] from an alt-block
+/// if it is not already in the DB.
+///
+/// If the transaction is in the main-chain this function will still fill in the
+/// [`AltTransactionInfos`](crate::tables::AltTransactionInfos) table, as that
+/// table holds data which we don't keep around for main-chain txs.
+///
+#[doc = doc_add_alt_block_inner_invariant!()]
+#[doc = doc_error!()]
+pub fn add_alt_transaction_blob(
+    tx: &VerifiedTransactionInformation,
+    tables: &mut impl TablesMut,
+) -> Result<(), RuntimeError> {
+    tables.alt_transaction_infos_mut().put(
+        &tx.tx_hash,
+        &AltTransactionInfo {
+            tx_weight: tx.tx_weight,
+            fee: tx.fee,
+            tx_hash: tx.tx_hash,
+        },
+    )?;
+
+    if tables.tx_ids().get(&tx.tx_hash).is_ok()
+        || tables.alt_transaction_blobs().get(&tx.tx_hash).is_ok()
+    {
+        return Ok(());
+    }
+
+    tables
+        .alt_transaction_blobs_mut()
+        .put(&tx.tx_hash, StorableVec::wrap_ref(&tx.tx_blob))?;
+
+    Ok(())
+}
+
+/// Retrieve a [`VerifiedTransactionInformation`] from the database.
+///
+#[doc = doc_error!()]
+pub fn get_alt_transaction(
+    tx_hash: &TxHash,
+    tables: &impl Tables,
+) -> Result<VerifiedTransactionInformation, RuntimeError> {
+    let tx_info = tables.alt_transaction_infos().get(tx_hash)?;
+
+    let tx_blob = match tables.alt_transaction_blobs().get(tx_hash) {
+        Ok(blob) => blob.0,
+        Err(RuntimeError::KeyNotFound) => {
+            let tx_id = tables.tx_ids().get(tx_hash)?;
+
+            let blob = tables.tx_blobs().get(&tx_id)?;
+
+            blob.0
+        }
+        Err(e) => return Err(e),
+    };
+
+    Ok(VerifiedTransactionInformation {
+        tx: Transaction::read(&mut tx_blob.as_slice()).unwrap(),
+        tx_blob,
+        tx_weight: tx_info.tx_weight,
+        fee: tx_info.fee,
+        tx_hash: tx_info.tx_hash,
+    })
+}

storage/blockchain/src/ops/block.rs

@@ -2,16 +2,26 @@
 
 //---------------------------------------------------------------------------------------------------- Import
 use bytemuck::TransparentWrapper;
-use monero_serai::block::Block;
+use monero_serai::{
+    block::{Block, BlockHeader},
+    transaction::Transaction,
+};
 
 use cuprate_database::{
     RuntimeError, StorableVec, {DatabaseRo, DatabaseRw},
 };
-use cuprate_helper::map::{combine_low_high_bits_to_u128, split_u128_into_low_high_bits};
+use cuprate_helper::{
-use cuprate_types::{ExtendedBlockHeader, HardFork, VerifiedBlockInformation};
+    map::{combine_low_high_bits_to_u128, split_u128_into_low_high_bits},
+    tx::tx_fee,
+};
+use cuprate_types::{
+    AltBlockInformation, ChainId, ExtendedBlockHeader, HardFork, VerifiedBlockInformation,
+    VerifiedTransactionInformation,
+};
 
 use crate::{
     ops::{
+        alt_block,
         blockchain::{chain_height, cumulative_generated_coins},
         macros::doc_error,
         output::get_rct_num_outputs,
@@ -33,11 +43,6 @@ use crate::{
 /// This function will panic if:
 /// - `block.height > u32::MAX` (not normally possible)
 /// - `block.height` is not != [`chain_height`]
-///
-/// # Already exists
-/// This function will operate normally even if `block` already
-/// exists, i.e., this function will not return `Err` even if you
-/// call this function infinitely with the same block.
 // no inline, too big.
 pub fn add_block(
     block: &VerifiedBlockInformation,
@@ -74,10 +79,10 @@ pub fn add_block(
 
     //------------------------------------------------------ Transaction / Outputs / Key Images
     // Add the miner transaction first.
-    {
+    let mining_tx_index = {
         let tx = &block.block.miner_transaction;
-        add_tx(tx, &tx.serialize(), &tx.hash(), &chain_height, tables)?;
+        add_tx(tx, &tx.serialize(), &tx.hash(), &chain_height, tables)?
-    }
+    };
 
     for tx in &block.txs {
         add_tx(&tx.tx, &tx.tx_blob, &tx.tx_hash, &chain_height, tables)?;
@@ -107,16 +112,23 @@ pub fn add_block(
             cumulative_rct_outs,
             timestamp: block.block.header.timestamp,
             block_hash: block.block_hash,
-            // INVARIANT: #[cfg] @ lib.rs asserts `usize == u64`
+            weight: block.weight,
-            weight: block.weight as u64,
+            long_term_weight: block.long_term_weight,
-            long_term_weight: block.long_term_weight as u64,
+            mining_tx_index,
         },
     )?;
 
-    // Block blobs.
+    // Block header blob.
-    tables
+    tables.block_header_blobs_mut().put(
-        .block_blobs_mut()
+        &block.height,
-        .put(&block.height, StorableVec::wrap_ref(&block.block_blob))?;
+        StorableVec::wrap_ref(&block.block.header.serialize()),
+    )?;
+
+    // Block transaction hashes
+    tables.block_txs_hashes_mut().put(
+        &block.height,
+        StorableVec::wrap_ref(&block.block.transactions),
+    )?;
 
     // Block heights.
     tables
@@ -130,37 +142,87 @@ pub fn add_block(
 /// Remove the top/latest block from the database.
 ///
 /// The removed block's data is returned.
+///
+/// If a [`ChainId`] is specified the popped block will be added to the alt block tables under
+/// that [`ChainId`]. Otherwise, the block will be completely removed from the DB.
 #[doc = doc_error!()]
 ///
 /// In `pop_block()`'s case, [`RuntimeError::KeyNotFound`]
 /// will be returned if there are no blocks left.
 // no inline, too big
 pub fn pop_block(
+    move_to_alt_chain: Option<ChainId>,
     tables: &mut impl TablesMut,
 ) -> Result<(BlockHeight, BlockHash, Block), RuntimeError> {
     //------------------------------------------------------ Block Info
     // Remove block data from tables.
-    let (block_height, block_hash) = {
     let (block_height, block_info) = tables.block_infos_mut().pop_last()?;
-        (block_height, block_info.block_hash)
-    };
 
     // Block heights.
-    tables.block_heights_mut().delete(&block_hash)?;
+    tables.block_heights_mut().delete(&block_info.block_hash)?;
 
     // Block blobs.
-    // We deserialize the block blob into a `Block`, such
+    //
-    // that we can remove the associated transactions later.
+    // We deserialize the block header blob and mining transaction blob
-    let block_blob = tables.block_blobs_mut().take(&block_height)?.0;
+    // to form a `Block`, such that we can remove the associated transactions
-    let block = Block::read(&mut block_blob.as_slice())?;
+    // later.
+    let block_header = tables.block_header_blobs_mut().take(&block_height)?.0;
+    let block_txs_hashes = tables.block_txs_hashes_mut().take(&block_height)?.0;
+    let miner_transaction = tables.tx_blobs().get(&block_info.mining_tx_index)?.0;
+    let block = Block {
+        header: BlockHeader::read(&mut block_header.as_slice())?,
+        miner_transaction: Transaction::read(&mut miner_transaction.as_slice())?,
+        transactions: block_txs_hashes,
+    };
 
     //------------------------------------------------------ Transaction / Outputs / Key Images
     remove_tx(&block.miner_transaction.hash(), tables)?;
-    for tx_hash in &block.transactions {
+
-        remove_tx(tx_hash, tables)?;
+    let remove_tx_iter = block.transactions.iter().map(|tx_hash| {
+        let (_, tx) = remove_tx(tx_hash, tables)?;
+        Ok::<_, RuntimeError>(tx)
+    });
+
+    if let Some(chain_id) = move_to_alt_chain {
+        let txs = remove_tx_iter
+            .map(|result| {
+                let tx = result?;
+                Ok(VerifiedTransactionInformation {
+                    tx_weight: tx.weight(),
+                    tx_blob: tx.serialize(),
+                    tx_hash: tx.hash(),
+                    fee: tx_fee(&tx),
+                    tx,
+                })
+            })
+            .collect::<Result<Vec<VerifiedTransactionInformation>, RuntimeError>>()?;
+
+        alt_block::add_alt_block(
+            &AltBlockInformation {
+                block: block.clone(),
+                block_blob: block.serialize(),
+                txs,
+                block_hash: block_info.block_hash,
+                // We know the PoW is valid for this block so just set it so it will always verify as valid.
+                pow_hash: [0; 32],
+                height: block_height,
+                weight: block_info.weight,
+                long_term_weight: block_info.long_term_weight,
+                cumulative_difficulty: combine_low_high_bits_to_u128(
+                    block_info.cumulative_difficulty_low,
+                    block_info.cumulative_difficulty_high,
+                ),
+                chain_id,
+            },
+            tables,
+        )?;
+    } else {
+        for result in remove_tx_iter {
+            drop(result?);
+        }
     }
 
-    Ok((block_height, block_hash, block))
+    Ok((block_height, block_info.block_hash, block))
 }
 
 //---------------------------------------------------------------------------------------------------- `get_block_extended_header_*`
@@ -193,26 +255,22 @@ pub fn get_block_extended_header_from_height(
     tables: &impl Tables,
 ) -> Result<ExtendedBlockHeader, RuntimeError> {
     let block_info = tables.block_infos().get(block_height)?;
-    let block_blob = tables.block_blobs().get(block_height)?.0;
+    let block_header_blob = tables.block_header_blobs().get(block_height)?.0;
-    let block = Block::read(&mut block_blob.as_slice())?;
+    let block_header = BlockHeader::read(&mut block_header_blob.as_slice())?;
 
     let cumulative_difficulty = combine_low_high_bits_to_u128(
         block_info.cumulative_difficulty_low,
         block_info.cumulative_difficulty_high,
     );
 
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "INVARIANT: #[cfg] @ lib.rs asserts `usize == u64`"
-    )]
     Ok(ExtendedBlockHeader {
         cumulative_difficulty,
-        version: HardFork::from_version(block.header.hardfork_version)
+        version: HardFork::from_version(block_header.hardfork_version)
             .expect("Stored block must have a valid hard-fork"),
-        vote: block.header.hardfork_signal,
+        vote: block_header.hardfork_signal,
-        timestamp: block.header.timestamp,
+        timestamp: block_header.timestamp,
-        block_weight: block_info.weight as usize,
+        block_weight: block_info.weight,
-        long_term_weight: block_info.long_term_weight as usize,
+        long_term_weight: block_info.long_term_weight,
     })
 }
 
@@ -265,21 +323,21 @@ pub fn block_exists(
 
 //---------------------------------------------------------------------------------------------------- Tests
 #[cfg(test)]
-#[expect(clippy::significant_drop_tightening, clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 mod test {
     use pretty_assertions::assert_eq;
 
     use cuprate_database::{Env, EnvInner, TxRw};
     use cuprate_test_utils::data::{BLOCK_V16_TX0, BLOCK_V1_TX2, BLOCK_V9_TX3};
 
-    use super::*;
-
     use crate::{
         ops::tx::{get_tx, tx_exists},
         tables::OpenTables,
         tests::{assert_all_tables_are_empty, tmp_concrete_env, AssertTableLen},
     };
 
+    use super::*;
+
     /// Tests all above block functions.
     ///
     /// Note that this doesn't test the correctness of values added, as the
@@ -331,7 +389,8 @@ mod test {
             // Assert only the proper tables were added to.
             AssertTableLen {
                 block_infos: 3,
-                block_blobs: 3,
+                block_header_blobs: 3,
+                block_txs_hashes: 3,
                 block_heights: 3,
                 key_images: 69,
                 num_outputs: 41,
@@ -414,7 +473,8 @@ mod test {
             for block_hash in block_hashes.into_iter().rev() {
                 println!("pop_block(): block_hash: {}", hex::encode(block_hash));
 
-                let (_popped_height, popped_hash, _popped_block) = pop_block(&mut tables).unwrap();
+                let (_popped_height, popped_hash, _popped_block) =
+                    pop_block(None, &mut tables).unwrap();
 
                 assert_eq!(block_hash, popped_hash);
 

storage/blockchain/src/ops/blockchain.rs

@@ -138,7 +138,8 @@ mod test {
             // Assert reads are correct.
             AssertTableLen {
                 block_infos: 3,
-                block_blobs: 3,
+                block_header_blobs: 3,
+                block_txs_hashes: 3,
                 block_heights: 3,
                 key_images: 69,
                 num_outputs: 41,

storage/blockchain/src/ops/macros.rs

@@ -31,3 +31,25 @@ When calling this function, ensure that either:
     };
 }
 pub(super) use doc_add_block_inner_invariant;
+
+/// Generate `# Invariant` documentation for internal alt block `fn`'s
+/// that should be called directly with caution.
+///
+/// This is pretty much the same as [`doc_add_block_inner_invariant`],
+/// it's not worth the effort to reduce the duplication.
+macro_rules! doc_add_alt_block_inner_invariant {
+    () => {
+            r#"# ⚠️ Invariant ⚠️
+This function mainly exists to be used internally by the parent function [`crate::ops::alt_block::add_alt_block`].
+
+`add_alt_block()` makes sure all data related to the input is mutated, while
+this function _does not_, it specifically mutates _particular_ tables.
+
+This is usually undesired - although this function is still available to call directly.
+
+When calling this function, ensure that either:
+1. This effect (incomplete database mutation) is what is desired, or that...
+2. ...the other tables will also be mutated to a correct state"#
+    };
+}
+pub(super) use doc_add_alt_block_inner_invariant;

storage/blockchain/src/ops/mod.rs

@@ -94,7 +94,7 @@
 //! // Read the data, assert it is correct.
 //! let tx_rw = env_inner.tx_rw()?;
 //! let mut tables = env_inner.open_tables_mut(&tx_rw)?;
-//! let (height, hash, serai_block) = pop_block(&mut tables)?;
+//! let (height, hash, serai_block) = pop_block(None, &mut tables)?;
 //!
 //! assert_eq!(height, 0);
 //! assert_eq!(serai_block, block.block);
@@ -102,6 +102,7 @@
 //! # Ok(()) }
 //! ```
 
+pub mod alt_block;
 pub mod block;
 pub mod blockchain;
 pub mod key_image;

storage/blockchain/src/ops/output.rs

@@ -316,7 +316,8 @@ mod test {
             // Assert proper tables were added to.
             AssertTableLen {
                 block_infos: 0,
-                block_blobs: 0,
+                block_header_blobs: 0,
+                block_txs_hashes: 0,
                 block_heights: 0,
                 key_images: 0,
                 num_outputs: 1,

storage/blockchain/src/ops/tx.rs

@@ -366,7 +366,8 @@ mod test {
             // Assert only the proper tables were added to.
             AssertTableLen {
                 block_infos: 0,
-                block_blobs: 0,
+                block_header_blobs: 0,
+                block_txs_hashes: 0,
                 block_heights: 0,
                 key_images: 4, // added to key images
                 pruned_tx_blobs: 0,

storage/blockchain/src/service/free.rs

@@ -4,11 +4,14 @@
 use std::sync::Arc;
 
 use cuprate_database::{ConcreteEnv, InitError};
+use cuprate_types::{AltBlockInformation, VerifiedBlockInformation};
 
-use crate::service::{init_read_service, init_write_service};
 use crate::{
     config::Config,
-    service::types::{BlockchainReadHandle, BlockchainWriteHandle},
+    service::{
+        init_read_service, init_write_service,
+        types::{BlockchainReadHandle, BlockchainWriteHandle},
+    },
 };
 
 //---------------------------------------------------------------------------------------------------- Init
@@ -81,6 +84,44 @@ pub(super) const fn compact_history_genesis_not_included<const INITIAL_BLOCKS: u
     top_block_height > INITIAL_BLOCKS && !(top_block_height - INITIAL_BLOCKS + 2).is_power_of_two()
 }
 
+//---------------------------------------------------------------------------------------------------- Map Block
+/// Maps [`AltBlockInformation`] to [`VerifiedBlockInformation`]
+///
+/// # Panics
+/// This will panic if the block is invalid, so should only be used on blocks that have been popped from
+/// the main-chain.
+pub(super) fn map_valid_alt_block_to_verified_block(
+    alt_block: AltBlockInformation,
+) -> VerifiedBlockInformation {
+    let total_fees = alt_block.txs.iter().map(|tx| tx.fee).sum::<u64>();
+    let total_miner_output = alt_block
+        .block
+        .miner_transaction
+        .prefix()
+        .outputs
+        .iter()
+        .map(|out| out.amount.unwrap_or(0))
+        .sum::<u64>();
+
+    VerifiedBlockInformation {
+        block: alt_block.block,
+        block_blob: alt_block.block_blob,
+        txs: alt_block
+            .txs
+            .into_iter()
+            .map(TryInto::try_into)
+            .collect::<Result<_, _>>()
+            .unwrap(),
+        block_hash: alt_block.block_hash,
+        pow_hash: alt_block.pow_hash,
+        height: alt_block.height,
+        generated_coins: total_miner_output - total_fees,
+        weight: alt_block.weight,
+        long_term_weight: alt_block.long_term_weight,
+        cumulative_difficulty: alt_block.cumulative_difficulty,
+    }
+}
+
 //---------------------------------------------------------------------------------------------------- Tests
 
 #[cfg(test)]

storage/blockchain/src/service/mod.rs

@@ -98,7 +98,7 @@
 //!
 //! // Block write was OK.
 //! let response = response_channel.await?;
-//! assert_eq!(response, BlockchainResponse::WriteBlockOk);
+//! assert_eq!(response, BlockchainResponse::Ok);
 //!
 //! // Now, let's try getting the block hash
 //! // of the block we just wrote.

storage/blockchain/src/service/read.rs

@@ -8,6 +8,7 @@ use std::{
 
 use rayon::{
     iter::{IntoParallelIterator, ParallelIterator},
+    prelude::*,
     ThreadPool,
 };
 use thread_local::ThreadLocal;
@@ -17,11 +18,15 @@ use cuprate_database_service::{init_thread_pool, DatabaseReadService, ReaderThre
 use cuprate_helper::map::combine_low_high_bits_to_u128;
 use cuprate_types::{
     blockchain::{BlockchainReadRequest, BlockchainResponse},
-    Chain, ExtendedBlockHeader, OutputOnChain,
+    Chain, ChainId, ExtendedBlockHeader, OutputOnChain,
 };
 
 use crate::{
     ops::{
+        alt_block::{
+            get_alt_block, get_alt_block_extended_header_from_height, get_alt_block_hash,
+            get_alt_chain_history_ranges,
+        },
         block::{
             block_exists, get_block_extended_header_from_height, get_block_height, get_block_info,
         },
@@ -33,8 +38,10 @@ use crate::{
         free::{compact_history_genesis_not_included, compact_history_index_to_height_offset},
         types::{BlockchainReadHandle, ResponseResult},
     },
-    tables::{BlockHeights, BlockInfos, OpenTables, Tables},
+    tables::{AltBlockHeights, BlockHeights, BlockInfos, OpenTables, Tables},
-    types::{Amount, AmountIndex, BlockHash, BlockHeight, KeyImage, PreRctOutputId},
+    types::{
+        AltBlockHeight, Amount, AmountIndex, BlockHash, BlockHeight, KeyImage, PreRctOutputId,
+    },
 };
 
 //---------------------------------------------------------------------------------------------------- init_read_service
@@ -87,7 +94,7 @@ fn map_request(
     match request {
         R::BlockExtendedHeader(block) => block_extended_header(env, block),
         R::BlockHash(block, chain) => block_hash(env, block, chain),
-        R::FindBlock(_) => todo!("Add alt blocks to DB"),
+        R::FindBlock(block_hash) => find_block(env, block_hash),
         R::FilterUnknownHashes(hashes) => filter_unknown_hashes(env, hashes),
         R::BlockExtendedHeaderInRange(range, chain) => {
             block_extended_header_in_range(env, range, chain)
@@ -99,6 +106,7 @@ fn map_request(
         R::KeyImagesSpent(set) => key_images_spent(env, set),
         R::CompactChainHistory => compact_chain_history(env),
         R::FindFirstUnknown(block_ids) => find_first_unknown(env, &block_ids),
+        R::AltBlocksInChain(chain_id) => alt_blocks_in_chain(env, chain_id),
     }
 
     /* SOMEDAY: post-request handling, run some code for each request? */
@@ -197,12 +205,41 @@ fn block_hash(env: &ConcreteEnv, block_height: BlockHeight, chain: Chain) -> Res
 
     let block_hash = match chain {
         Chain::Main => get_block_info(&block_height, &table_block_infos)?.block_hash,
-        Chain::Alt(_) => todo!("Add alt blocks to DB"),
+        Chain::Alt(chain) => {
+            get_alt_block_hash(&block_height, chain, &env_inner.open_tables(&tx_ro)?)?
+        }
     };
 
     Ok(BlockchainResponse::BlockHash(block_hash))
 }
 
+/// [`BlockchainReadRequest::FindBlock`]
+fn find_block(env: &ConcreteEnv, block_hash: BlockHash) -> ResponseResult {
+    // Single-threaded, no `ThreadLocal` required.
+    let env_inner = env.env_inner();
+    let tx_ro = env_inner.tx_ro()?;
+
+    let table_block_heights = env_inner.open_db_ro::<BlockHeights>(&tx_ro)?;
+
+    // Check the main chain first.
+    match table_block_heights.get(&block_hash) {
+        Ok(height) => return Ok(BlockchainResponse::FindBlock(Some((Chain::Main, height)))),
+        Err(RuntimeError::KeyNotFound) => (),
+        Err(e) => return Err(e),
+    }
+
+    let table_alt_block_heights = env_inner.open_db_ro::<AltBlockHeights>(&tx_ro)?;
+
+    match table_alt_block_heights.get(&block_hash) {
+        Ok(height) => Ok(BlockchainResponse::FindBlock(Some((
+            Chain::Alt(height.chain_id.into()),
+            height.height,
+        )))),
+        Err(RuntimeError::KeyNotFound) => Ok(BlockchainResponse::FindBlock(None)),
+        Err(e) => Err(e),
+    }
+}
+
 /// [`BlockchainReadRequest::FilterUnknownHashes`].
 #[inline]
 fn filter_unknown_hashes(env: &ConcreteEnv, mut hashes: HashSet<BlockHash>) -> ResponseResult {
@@ -253,7 +290,37 @@ fn block_extended_header_in_range(
                 get_block_extended_header_from_height(&block_height, tables)
             })
             .collect::<Result<Vec<ExtendedBlockHeader>, RuntimeError>>()?,
-        Chain::Alt(_) => todo!("Add alt blocks to DB"),
+        Chain::Alt(chain_id) => {
+            let ranges = {
+                let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
+                let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
+                let alt_chains = tables.alt_chain_infos();
+
+                get_alt_chain_history_ranges(range, chain_id, alt_chains)?
+            };
+
+            ranges
+                .par_iter()
+                .rev()
+                .flat_map(|(chain, range)| {
+                    range.clone().into_par_iter().map(|height| {
+                        let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
+                        let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
+
+                        match *chain {
+                            Chain::Main => get_block_extended_header_from_height(&height, tables),
+                            Chain::Alt(chain_id) => get_alt_block_extended_header_from_height(
+                                &AltBlockHeight {
+                                    chain_id: chain_id.into(),
+                                    height,
+                                },
+                                tables,
+                            ),
+                        }
+                    })
+                })
+                .collect::<Result<Vec<_>, _>>()?
+        }
     };
 
     Ok(BlockchainResponse::BlockExtendedHeaderInRange(vec))
@@ -492,3 +559,45 @@ fn find_first_unknown(env: &ConcreteEnv, block_ids: &[BlockHash]) -> ResponseRes
         BlockchainResponse::FindFirstUnknown(Some((idx, last_known_height + 1)))
     })
 }
+
+/// [`BlockchainReadRequest::AltBlocksInChain`]
+fn alt_blocks_in_chain(env: &ConcreteEnv, chain_id: ChainId) -> ResponseResult {
+    // Prepare tx/tables in `ThreadLocal`.
+    let env_inner = env.env_inner();
+    let tx_ro = thread_local(env);
+    let tables = thread_local(env);
+
+    // Get the history of this alt-chain.
+    let history = {
+        let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
+        let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
+        get_alt_chain_history_ranges(0..usize::MAX, chain_id, tables.alt_chain_infos())?
+    };
+
+    // Get all the blocks until we join the main-chain.
+    let blocks = history
+        .par_iter()
+        .rev()
+        .skip(1)
+        .flat_map(|(chain_id, range)| {
+            let Chain::Alt(chain_id) = chain_id else {
+                panic!("Should not have main chain blocks here we skipped last range");
+            };
+
+            range.clone().into_par_iter().map(|height| {
+                let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
+                let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
+
+                get_alt_block(
+                    &AltBlockHeight {
+                        chain_id: (*chain_id).into(),
+                        height,
+                    },
+                    tables,
+                )
+            })
+        })
+        .collect::<Result<_, _>>()?;
+
+    Ok(BlockchainResponse::AltBlocksInChain(blocks))
+}

storage/blockchain/src/service/tests.rs

@@ -13,13 +13,14 @@ use std::{
 };
 
 use pretty_assertions::assert_eq;
+use rand::Rng;
 use tower::{Service, ServiceExt};
 
 use cuprate_database::{ConcreteEnv, DatabaseIter, DatabaseRo, Env, EnvInner, RuntimeError};
 use cuprate_test_utils::data::{BLOCK_V16_TX0, BLOCK_V1_TX2, BLOCK_V9_TX3};
 use cuprate_types::{
     blockchain::{BlockchainReadRequest, BlockchainResponse, BlockchainWriteRequest},
-    Chain, OutputOnChain, VerifiedBlockInformation,
+    Chain, ChainId, OutputOnChain, VerifiedBlockInformation,
 };
 
 use crate::{
@@ -31,7 +32,7 @@ use crate::{
     },
     service::{init, BlockchainReadHandle, BlockchainWriteHandle},
     tables::{OpenTables, Tables, TablesIter},
-    tests::AssertTableLen,
+    tests::{map_verified_block_to_alt, AssertTableLen},
     types::{Amount, AmountIndex, PreRctOutputId},
 };
 
@@ -87,7 +88,7 @@ async fn test_template(
         let request = BlockchainWriteRequest::WriteBlock(block);
         let response_channel = writer.call(request);
         let response = response_channel.await.unwrap();
-        assert_eq!(response, BlockchainResponse::WriteBlockOk);
+        assert_eq!(response, BlockchainResponse::Ok);
     }
 
     //----------------------------------------------------------------------- Reset the transaction
@@ -240,18 +241,20 @@ async fn test_template(
 
     //----------------------------------------------------------------------- Output checks
     // Create the map of amounts and amount indices.
-    //
-    // FIXME: There's definitely a better way to map
-    // `Vec<PreRctOutputId>` -> `HashMap<u64, HashSet<u64>>`
     let (map, output_count) = {
-        let mut ids = tables
+        let mut map = HashMap::<Amount, HashSet<AmountIndex>>::new();
+
+        // Used later to compare the amount of Outputs
+        // returned in the Response is equal to the amount
+        // we asked for.
+        let mut output_count: usize = 0;
+
+        tables
             .outputs_iter()
             .keys()
             .unwrap()
             .map(Result::unwrap)
-            .collect::<Vec<PreRctOutputId>>();
+            .chain(
-
-        ids.extend(
                 tables
                     .rct_outputs_iter()
                     .keys()
@@ -261,21 +264,15 @@ async fn test_template(
                         amount: 0,
                         amount_index,
                     }),
-        );
+            )
-
+            .for_each(|id| {
-        // Used later to compare the amount of Outputs
+                output_count += 1;
-        // returned in the Response is equal to the amount
-        // we asked for.
-        let output_count = ids.len();
-
-        let mut map = HashMap::<Amount, HashSet<AmountIndex>>::new();
-        for id in ids {
                 map.entry(id.amount)
                     .and_modify(|set| {
                         set.insert(id.amount_index);
                     })
                     .or_insert_with(|| HashSet::from([id.amount_index]));
-        }
+            });
 
         (map, output_count)
     };
@@ -346,7 +343,8 @@ async fn v1_tx2() {
         14_535_350_982_449,
         AssertTableLen {
             block_infos: 1,
-            block_blobs: 1,
+            block_header_blobs: 1,
+            block_txs_hashes: 1,
             block_heights: 1,
             key_images: 65,
             num_outputs: 41,
@@ -372,7 +370,8 @@ async fn v9_tx3() {
         3_403_774_022_163,
         AssertTableLen {
             block_infos: 1,
-            block_blobs: 1,
+            block_header_blobs: 1,
+            block_txs_hashes: 1,
             block_heights: 1,
             key_images: 4,
             num_outputs: 0,
@@ -398,7 +397,8 @@ async fn v16_tx0() {
         600_000_000_000,
         AssertTableLen {
             block_infos: 1,
-            block_blobs: 1,
+            block_header_blobs: 1,
+            block_txs_hashes: 1,
             block_heights: 1,
             key_images: 0,
             num_outputs: 0,
@@ -415,3 +415,92 @@ async fn v16_tx0() {
     )
     .await;
 }
+
+/// Tests the alt-chain requests and responses.
+#[tokio::test]
+async fn alt_chain_requests() {
+    let (reader, mut writer, _, _tempdir) = init_service();
+
+    // Set up the test by adding blocks to the main-chain.
+    for (i, mut block) in [BLOCK_V9_TX3.clone(), BLOCK_V16_TX0.clone()]
+        .into_iter()
+        .enumerate()
+    {
+        block.height = i;
+
+        let request = BlockchainWriteRequest::WriteBlock(block);
+        writer.call(request).await.unwrap();
+    }
+
+    // Generate the alt-blocks.
+    let mut prev_hash = BLOCK_V9_TX3.block_hash;
+    let mut chain_id = 1;
+    let alt_blocks = [&BLOCK_V16_TX0, &BLOCK_V9_TX3, &BLOCK_V1_TX2]
+        .into_iter()
+        .enumerate()
+        .map(|(i, block)| {
+            let mut block = (**block).clone();
+            block.height = i + 1;
+            block.block.header.previous = prev_hash;
+            block.block_blob = block.block.serialize();
+
+            prev_hash = block.block_hash;
+            // Randomly either keep the [`ChainId`] the same or change it to a new value.
+            chain_id += rand::thread_rng().gen_range(0..=1);
+
+            map_verified_block_to_alt(block, ChainId(chain_id.try_into().unwrap()))
+        })
+        .collect::<Vec<_>>();
+
+    for block in &alt_blocks {
+        // Request a block to be written, assert it was written.
+        let request = BlockchainWriteRequest::WriteAltBlock(block.clone());
+        let response_channel = writer.call(request);
+        let response = response_channel.await.unwrap();
+        assert_eq!(response, BlockchainResponse::Ok);
+    }
+
+    // Get the full alt-chain
+    let request = BlockchainReadRequest::AltBlocksInChain(ChainId(chain_id.try_into().unwrap()));
+    let response = reader.clone().oneshot(request).await.unwrap();
+
+    let BlockchainResponse::AltBlocksInChain(blocks) = response else {
+        panic!("Wrong response type was returned");
+    };
+
+    assert_eq!(blocks.len(), alt_blocks.len());
+    for (got_block, alt_block) in blocks.into_iter().zip(alt_blocks) {
+        assert_eq!(got_block.block_blob, alt_block.block_blob);
+        assert_eq!(got_block.block_hash, alt_block.block_hash);
+        assert_eq!(got_block.chain_id, alt_block.chain_id);
+        assert_eq!(got_block.txs, alt_block.txs);
+    }
+
+    // Flush all alt blocks.
+    let request = BlockchainWriteRequest::FlushAltBlocks;
+    let response = writer.ready().await.unwrap().call(request).await.unwrap();
+    assert_eq!(response, BlockchainResponse::Ok);
+
+    // Pop blocks from the main chain
+    let request = BlockchainWriteRequest::PopBlocks(1);
+    let response = writer.ready().await.unwrap().call(request).await.unwrap();
+
+    let BlockchainResponse::PopBlocks(old_main_chain_id) = response else {
+        panic!("Wrong response type was returned");
+    };
+
+    // Check we have popped the top block.
+    let request = BlockchainReadRequest::ChainHeight;
+    let response = reader.clone().oneshot(request).await.unwrap();
+    assert!(matches!(response, BlockchainResponse::ChainHeight(1, _)));
+
+    // Attempt to add the popped block back.
+    let request = BlockchainWriteRequest::ReverseReorg(old_main_chain_id);
+    let response = writer.ready().await.unwrap().call(request).await.unwrap();
+    assert_eq!(response, BlockchainResponse::Ok);
+
+    // Check we have the popped block back.
+    let request = BlockchainReadRequest::ChainHeight;
+    let response = reader.clone().oneshot(request).await.unwrap();
+    assert!(matches!(response, BlockchainResponse::ChainHeight(2, _)));
+}

storage/blockchain/src/service/write.rs

@@ -1,20 +1,30 @@
 //! Database writer thread definitions and logic.
-
 //---------------------------------------------------------------------------------------------------- Import
 use std::sync::Arc;
 
-use cuprate_database::{ConcreteEnv, Env, EnvInner, RuntimeError, TxRw};
+use cuprate_database::{ConcreteEnv, DatabaseRo, Env, EnvInner, RuntimeError, TxRw};
 use cuprate_database_service::DatabaseWriteHandle;
 use cuprate_types::{
     blockchain::{BlockchainResponse, BlockchainWriteRequest},
-    VerifiedBlockInformation,
+    AltBlockInformation, Chain, ChainId, VerifiedBlockInformation,
 };
 
 use crate::{
-    service::types::{BlockchainWriteHandle, ResponseResult},
+    service::{
-    tables::OpenTables,
+        free::map_valid_alt_block_to_verified_block,
+        types::{BlockchainWriteHandle, ResponseResult},
+    },
+    tables::{OpenTables, Tables},
+    types::AltBlockHeight,
 };
 
+/// Write functions within this module abort if the write transaction
+/// could not be aborted successfully to maintain atomicity.
+///
+/// This is the panic message if the `abort()` fails.
+const TX_RW_ABORT_FAIL: &str =
+    "Could not maintain blockchain database atomicity by aborting write transaction";
+
 //---------------------------------------------------------------------------------------------------- init_write_service
 /// Initialize the blockchain write service from a [`ConcreteEnv`].
 pub fn init_write_service(env: Arc<ConcreteEnv>) -> BlockchainWriteHandle {
@@ -29,6 +39,12 @@ fn handle_blockchain_request(
 ) -> Result<BlockchainResponse, RuntimeError> {
     match req {
         BlockchainWriteRequest::WriteBlock(block) => write_block(env, block),
+        BlockchainWriteRequest::WriteAltBlock(alt_block) => write_alt_block(env, alt_block),
+        BlockchainWriteRequest::PopBlocks(numb_blocks) => pop_blocks(env, *numb_blocks),
+        BlockchainWriteRequest::ReverseReorg(old_main_chain_id) => {
+            reverse_reorg(env, *old_main_chain_id)
+        }
+        BlockchainWriteRequest::FlushAltBlocks => flush_alt_blocks(env),
     }
 }
 
@@ -55,13 +71,140 @@ fn write_block(env: &ConcreteEnv, block: &VerifiedBlockInformation) -> ResponseR
     match result {
         Ok(()) => {
             TxRw::commit(tx_rw)?;
-            Ok(BlockchainResponse::WriteBlockOk)
+            Ok(BlockchainResponse::Ok)
         }
         Err(e) => {
-            // INVARIANT: ensure database atomicity by aborting
+            TxRw::abort(tx_rw).expect(TX_RW_ABORT_FAIL);
-            // the transaction on `add_block()` failures.
+            Err(e)
-            TxRw::abort(tx_rw)
+        }
-                .expect("could not maintain database atomicity by aborting write transaction");
+    }
+}
+
+/// [`BlockchainWriteRequest::WriteAltBlock`].
+#[inline]
+fn write_alt_block(env: &ConcreteEnv, block: &AltBlockInformation) -> ResponseResult {
+    let env_inner = env.env_inner();
+    let tx_rw = env_inner.tx_rw()?;
+
+    let result = {
+        let mut tables_mut = env_inner.open_tables_mut(&tx_rw)?;
+        crate::ops::alt_block::add_alt_block(block, &mut tables_mut)
+    };
+
+    match result {
+        Ok(()) => {
+            TxRw::commit(tx_rw)?;
+            Ok(BlockchainResponse::Ok)
+        }
+        Err(e) => {
+            TxRw::abort(tx_rw).expect(TX_RW_ABORT_FAIL);
+            Err(e)
+        }
+    }
+}
+
+/// [`BlockchainWriteRequest::PopBlocks`].
+fn pop_blocks(env: &ConcreteEnv, numb_blocks: usize) -> ResponseResult {
+    let env_inner = env.env_inner();
+    let mut tx_rw = env_inner.tx_rw()?;
+
+    // FIXME: turn this function into a try block once stable.
+    let mut result = || {
+        // flush all the current alt blocks as they may reference blocks to be popped.
+        crate::ops::alt_block::flush_alt_blocks(&env_inner, &mut tx_rw)?;
+
+        let mut tables_mut = env_inner.open_tables_mut(&tx_rw)?;
+        // generate a `ChainId` for the popped blocks.
+        let old_main_chain_id = ChainId(rand::random());
+
+        // pop the blocks
+        for _ in 0..numb_blocks {
+            crate::ops::block::pop_block(Some(old_main_chain_id), &mut tables_mut)?;
+        }
+
+        Ok(old_main_chain_id)
+    };
+
+    match result() {
+        Ok(old_main_chain_id) => {
+            TxRw::commit(tx_rw)?;
+            Ok(BlockchainResponse::PopBlocks(old_main_chain_id))
+        }
+        Err(e) => {
+            TxRw::abort(tx_rw).expect(TX_RW_ABORT_FAIL);
+            Err(e)
+        }
+    }
+}
+
+/// [`BlockchainWriteRequest::ReverseReorg`].
+fn reverse_reorg(env: &ConcreteEnv, chain_id: ChainId) -> ResponseResult {
+    let env_inner = env.env_inner();
+    let mut tx_rw = env_inner.tx_rw()?;
+
+    // FIXME: turn this function into a try block once stable.
+    let mut result = || {
+        let mut tables_mut = env_inner.open_tables_mut(&tx_rw)?;
+
+        let chain_info = tables_mut.alt_chain_infos().get(&chain_id.into())?;
+        // Although this doesn't guarantee the chain was popped from the main-chain, it's an easy
+        // thing for us to check.
+        assert_eq!(Chain::from(chain_info.parent_chain), Chain::Main);
+
+        let top_block_height =
+            crate::ops::blockchain::top_block_height(tables_mut.block_heights())?;
+
+        // pop any blocks that were added as part of a re-org.
+        for _ in chain_info.common_ancestor_height..top_block_height {
+            crate::ops::block::pop_block(None, &mut tables_mut)?;
+        }
+
+        // Add the old main chain blocks back to the main chain.
+        for height in (chain_info.common_ancestor_height + 1)..chain_info.chain_height {
+            let alt_block = crate::ops::alt_block::get_alt_block(
+                &AltBlockHeight {
+                    chain_id: chain_id.into(),
+                    height,
+                },
+                &tables_mut,
+            )?;
+            let verified_block = map_valid_alt_block_to_verified_block(alt_block);
+            crate::ops::block::add_block(&verified_block, &mut tables_mut)?;
+        }
+
+        drop(tables_mut);
+        crate::ops::alt_block::flush_alt_blocks(&env_inner, &mut tx_rw)?;
+
+        Ok(())
+    };
+
+    match result() {
+        Ok(()) => {
+            TxRw::commit(tx_rw)?;
+            Ok(BlockchainResponse::Ok)
+        }
+        Err(e) => {
+            TxRw::abort(tx_rw).expect(TX_RW_ABORT_FAIL);
+            Err(e)
+        }
+    }
+}
+
+/// [`BlockchainWriteRequest::FlushAltBlocks`].
+#[inline]
+fn flush_alt_blocks(env: &ConcreteEnv) -> ResponseResult {
+    let env_inner = env.env_inner();
+    let mut tx_rw = env_inner.tx_rw()?;
+
+    let result = crate::ops::alt_block::flush_alt_blocks(&env_inner, &mut tx_rw);
+
+    match result {
+        Ok(()) => {
+            TxRw::commit(tx_rw)?;
+            Ok(BlockchainResponse::Ok)
+        }
+        Err(e) => {
+            TxRw::abort(tx_rw).expect(TX_RW_ABORT_FAIL);
             Err(e)
         }
     }

storage/blockchain/src/tables.rs

@@ -9,7 +9,7 @@
 //! Table structs are `CamelCase`, and their static string
 //! names used by the actual database backend are `snake_case`.
 //!
-//! For example: [`BlockBlobs`] -> `block_blobs`.
+//! For example: [`BlockHeaderBlobs`] -> `block_header_blobs`.
 //!
 //! # Traits
 //! This module also contains a set of traits for
@@ -17,9 +17,10 @@
 
 //---------------------------------------------------------------------------------------------------- Import
 use crate::types::{
-    Amount, AmountIndex, AmountIndices, BlockBlob, BlockHash, BlockHeight, BlockInfo, KeyImage,
+    AltBlockHeight, AltChainInfo, AltTransactionInfo, Amount, AmountIndex, AmountIndices,
-    Output, PreRctOutputId, PrunableBlob, PrunableHash, PrunedBlob, RctOutput, TxBlob, TxHash,
+    BlockBlob, BlockHash, BlockHeaderBlob, BlockHeight, BlockInfo, BlockTxHashes,
-    TxId, UnlockTime,
+    CompactAltBlockInfo, KeyImage, Output, PreRctOutputId, PrunableBlob, PrunableHash, PrunedBlob,
+    RawChainId, RctOutput, TxBlob, TxHash, TxId, UnlockTime,
 };
 
 //---------------------------------------------------------------------------------------------------- Tables
@@ -29,22 +30,28 @@ use crate::types::{
 // - If adding/changing a table also edit:
 //   - the tests in `src/backend/tests.rs`
 cuprate_database::define_tables! {
-    /// Serialized block blobs (bytes).
+    /// Serialized block header blobs (bytes).
     ///
-    /// Contains the serialized version of all blocks.
+    /// Contains the serialized version of all blocks headers.
-    0 => BlockBlobs,
+    0 => BlockHeaderBlobs,
-    BlockHeight => BlockBlob,
+    BlockHeight => BlockHeaderBlob,
+
+    /// Block transactions hashes
+    ///
+    /// Contains all the transaction hashes of all blocks.
+    1 => BlockTxsHashes,
+    BlockHeight => BlockTxHashes,
 
     /// Block heights.
     ///
     /// Contains the height of all blocks.
-    1 => BlockHeights,
+    2 => BlockHeights,
     BlockHash => BlockHeight,
 
     /// Block information.
     ///
     /// Contains metadata of all blocks.
-    2 => BlockInfos,
+    3 => BlockInfos,
     BlockHeight => BlockInfo,
 
     /// Set of key images.
@@ -53,38 +60,38 @@ cuprate_database::define_tables! {
     ///
     /// This table has `()` as the value type, as in,
     /// it is a set of key images.
-    3 => KeyImages,
+    4 => KeyImages,
     KeyImage => (),
 
     /// Maps an output's amount to the number of outputs with that amount.
     ///
     /// For example, if there are 5 outputs with `amount = 123`
     /// then calling `get(123)` on this table will return 5.
-    4 => NumOutputs,
+    5 => NumOutputs,
     Amount => u64,
 
     /// Pre-RCT output data.
-    5 => Outputs,
+    6 => Outputs,
     PreRctOutputId => Output,
 
     /// Pruned transaction blobs (bytes).
     ///
     /// Contains the pruned portion of serialized transaction data.
-    6 => PrunedTxBlobs,
+    7 => PrunedTxBlobs,
     TxId => PrunedBlob,
 
     /// Prunable transaction blobs (bytes).
     ///
     /// Contains the prunable portion of serialized transaction data.
     // SOMEDAY: impl when `monero-serai` supports pruning
-    7 => PrunableTxBlobs,
+    8 => PrunableTxBlobs,
     TxId => PrunableBlob,
 
     /// Prunable transaction hashes.
     ///
     /// Contains the prunable portion of transaction hashes.
     // SOMEDAY: impl when `monero-serai` supports pruning
-    8 => PrunableHashes,
+    9 => PrunableHashes,
     TxId => PrunableHash,
 
     // SOMEDAY: impl a properties table:
@@ -94,41 +101,75 @@ cuprate_database::define_tables! {
     // StorableString => StorableVec,
 
     /// RCT output data.
-    9 => RctOutputs,
+    10 => RctOutputs,
     AmountIndex => RctOutput,
 
     /// Transaction blobs (bytes).
     ///
     /// Contains the serialized version of all transactions.
     // SOMEDAY: remove when `monero-serai` supports pruning
-    10 => TxBlobs,
+    11 => TxBlobs,
     TxId => TxBlob,
 
     /// Transaction indices.
     ///
     /// Contains the indices all transactions.
-    11 => TxIds,
+    12 => TxIds,
     TxHash => TxId,
 
     /// Transaction heights.
     ///
     /// Contains the block height associated with all transactions.
-    12 => TxHeights,
+    13 => TxHeights,
     TxId => BlockHeight,
 
     /// Transaction outputs.
     ///
     /// Contains the list of `AmountIndex`'s of the
     /// outputs associated with all transactions.
-    13 => TxOutputs,
+    14 => TxOutputs,
     TxId => AmountIndices,
 
     /// Transaction unlock time.
     ///
     /// Contains the unlock time of transactions IF they have one.
     /// Transactions without unlock times will not exist in this table.
-    14 => TxUnlockTime,
+    15 => TxUnlockTime,
     TxId => UnlockTime,
+
+    /// Information on alt-chains.
+    16 => AltChainInfos,
+    RawChainId => AltChainInfo,
+
+    /// Alt-block heights.
+    ///
+    /// Contains the height of all alt-blocks.
+    17 => AltBlockHeights,
+    BlockHash => AltBlockHeight,
+
+    /// Alt-block information.
+    ///
+    /// Contains information on all alt-blocks.
+    18 => AltBlocksInfo,
+    AltBlockHeight => CompactAltBlockInfo,
+
+    /// Alt-block blobs.
+    ///
+    /// Contains the raw bytes of all alt-blocks.
+    19 => AltBlockBlobs,
+    AltBlockHeight => BlockBlob,
+
+    /// Alt-block transaction blobs.
+    ///
+    /// Contains the raw bytes of alt transactions, if those transactions are not in the main-chain.
+    20 => AltTransactionBlobs,
+    TxHash => TxBlob,
+
+    /// Alt-block transaction information.
+    ///
+    /// Contains information on all alt transactions, even if they are in the main-chain.
+    21 => AltTransactionInfos,
+    TxHash => AltTransactionInfo,
 }
 
 //---------------------------------------------------------------------------------------------------- Tests

storage/blockchain/src/tests.rs

@@ -9,7 +9,8 @@ use std::{borrow::Cow, fmt::Debug};
 
 use pretty_assertions::assert_eq;
 
-use cuprate_database::{ConcreteEnv, DatabaseRo, Env, EnvInner};
+use cuprate_database::{DatabaseRo, Env, EnvInner};
+use cuprate_types::{AltBlockInformation, ChainId, VerifiedBlockInformation};
 
 use crate::{
     config::ConfigBuilder,
@@ -25,7 +26,8 @@ use crate::{
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) struct AssertTableLen {
     pub(crate) block_infos: u64,
-    pub(crate) block_blobs: u64,
+    pub(crate) block_header_blobs: u64,
+    pub(crate) block_txs_hashes: u64,
     pub(crate) block_heights: u64,
     pub(crate) key_images: u64,
     pub(crate) num_outputs: u64,
@@ -45,7 +47,8 @@ impl AssertTableLen {
     pub(crate) fn assert(self, tables: &impl Tables) {
         let other = Self {
             block_infos: tables.block_infos().len().unwrap(),
-            block_blobs: tables.block_blobs().len().unwrap(),
+            block_header_blobs: tables.block_header_blobs().len().unwrap(),
+            block_txs_hashes: tables.block_txs_hashes().len().unwrap(),
             block_heights: tables.block_heights().len().unwrap(),
             key_images: tables.key_images().len().unwrap(),
             num_outputs: tables.num_outputs().len().unwrap(),
@@ -68,8 +71,7 @@ impl AssertTableLen {
 /// Create an `Env` in a temporarily directory.
 /// The directory is automatically removed after the `TempDir` is dropped.
 ///
-/// FIXME: changing this to `-> impl Env` causes lifetime errors...
+pub(crate) fn tmp_concrete_env() -> (impl Env, tempfile::TempDir) {
-pub(crate) fn tmp_concrete_env() -> (ConcreteEnv, tempfile::TempDir) {
     let tempdir = tempfile::tempdir().unwrap();
     let config = ConfigBuilder::new()
         .db_directory(Cow::Owned(tempdir.path().into()))
@@ -81,10 +83,28 @@ pub(crate) fn tmp_concrete_env() -> (ConcreteEnv, tempfile::TempDir) {
 }
 
 /// Assert all the tables in the environment are empty.
-pub(crate) fn assert_all_tables_are_empty(env: &ConcreteEnv) {
+pub(crate) fn assert_all_tables_are_empty(env: &impl Env) {
     let env_inner = env.env_inner();
     let tx_ro = env_inner.tx_ro().unwrap();
     let tables = env_inner.open_tables(&tx_ro).unwrap();
     assert!(tables.all_tables_empty().unwrap());
     assert_eq!(crate::ops::tx::get_num_tx(tables.tx_ids()).unwrap(), 0);
 }
+
+pub(crate) fn map_verified_block_to_alt(
+    verified_block: VerifiedBlockInformation,
+    chain_id: ChainId,
+) -> AltBlockInformation {
+    AltBlockInformation {
+        block: verified_block.block,
+        block_blob: verified_block.block_blob,
+        txs: verified_block.txs,
+        block_hash: verified_block.block_hash,
+        pow_hash: verified_block.pow_hash,
+        height: verified_block.height,
+        weight: verified_block.weight,
+        long_term_weight: verified_block.long_term_weight,
+        cumulative_difficulty: verified_block.cumulative_difficulty,
+        chain_id,
+    }
+}

storage/blockchain/src/types.rs

@@ -41,12 +41,14 @@
 #![forbid(unsafe_code)] // if you remove this line i will steal your monero
 
 //---------------------------------------------------------------------------------------------------- Import
-use bytemuck::{Pod, Zeroable};
+use std::num::NonZero;
 
+use bytemuck::{Pod, Zeroable};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 use cuprate_database::{Key, StorableVec};
+use cuprate_types::{Chain, ChainId};
 
 //---------------------------------------------------------------------------------------------------- Aliases
 // These type aliases exist as many Monero-related types are the exact same.
@@ -64,6 +66,12 @@ pub type AmountIndices = StorableVec<AmountIndex>;
 /// A serialized block.
 pub type BlockBlob = StorableVec<u8>;
 
+/// A serialized block header
+pub type BlockHeaderBlob = StorableVec<u8>;
+
+/// A block transaction hashes
+pub type BlockTxHashes = StorableVec<[u8; 32]>;
+
 /// A block's hash.
 pub type BlockHash = [u8; 32];
 
@@ -164,6 +172,7 @@ impl Key for PreRctOutputId {}
 ///     block_hash: [54; 32],
 ///     cumulative_rct_outs: 2389,
 ///     long_term_weight: 2389,
+///     mining_tx_index: 23
 /// };
 /// let b = Storable::as_bytes(&a);
 /// let c: BlockInfo = Storable::from_bytes(b);
@@ -173,7 +182,7 @@ impl Key for PreRctOutputId {}
 /// # Size & Alignment
 /// ```rust
 /// # use cuprate_blockchain::types::*;
-/// assert_eq!(size_of::<BlockInfo>(), 88);
+/// assert_eq!(size_of::<BlockInfo>(), 96);
 /// assert_eq!(align_of::<BlockInfo>(), 8);
 /// ```
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -187,7 +196,7 @@ pub struct BlockInfo {
     /// The adjusted block size, in bytes.
     ///
     /// See [`block_weight`](https://monero-book.cuprate.org/consensus_rules/blocks/weights.html#blocks-weight).
-    pub weight: u64,
+    pub weight: usize,
     /// Least-significant 64 bits of the 128-bit cumulative difficulty.
     pub cumulative_difficulty_low: u64,
     /// Most-significant 64 bits of the 128-bit cumulative difficulty.
@@ -199,7 +208,9 @@ pub struct BlockInfo {
     /// The long term block weight, based on the median weight of the preceding `100_000` blocks.
     ///
     /// See [`long_term_weight`](https://monero-book.cuprate.org/consensus_rules/blocks/weights.html#long-term-block-weight).
-    pub long_term_weight: u64,
+    pub long_term_weight: usize,
+    /// [`TxId`] (u64) of the block coinbase transaction.
+    pub mining_tx_index: TxId,
 }
 
 //---------------------------------------------------------------------------------------------------- OutputFlags
@@ -324,6 +335,259 @@ pub struct RctOutput {
 }
 // TODO: local_index?
 
+//---------------------------------------------------------------------------------------------------- RawChain
+/// [`Chain`] in a format which can be stored in the DB.
+///
+/// Implements [`Into`] and [`From`] for [`Chain`].
+///
+/// ```rust
+/// # use std::borrow::*;
+/// # use cuprate_blockchain::{*, types::*};
+/// use cuprate_database::Storable;
+/// use cuprate_types::Chain;
+///
+/// // Assert Storable is correct.
+/// let a: RawChain = Chain::Main.into();
+/// let b = Storable::as_bytes(&a);
+/// let c: RawChain = Storable::from_bytes(b);
+/// assert_eq!(a, c);
+/// ```
+///
+/// # Size & Alignment
+/// ```rust
+/// # use cuprate_blockchain::types::*;
+/// assert_eq!(size_of::<RawChain>(), 8);
+/// assert_eq!(align_of::<RawChain>(), 8);
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Pod, Zeroable)]
+#[repr(transparent)]
+pub struct RawChain(u64);
+
+impl From<Chain> for RawChain {
+    fn from(value: Chain) -> Self {
+        match value {
+            Chain::Main => Self(0),
+            Chain::Alt(chain_id) => Self(chain_id.0.get()),
+        }
+    }
+}
+
+impl From<RawChain> for Chain {
+    fn from(value: RawChain) -> Self {
+        NonZero::new(value.0).map_or(Self::Main, |id| Self::Alt(ChainId(id)))
+    }
+}
+
+impl From<RawChainId> for RawChain {
+    fn from(value: RawChainId) -> Self {
+        // A [`ChainID`] with an inner value of `0` is invalid.
+        assert_ne!(value.0, 0);
+
+        Self(value.0)
+    }
+}
+
+//---------------------------------------------------------------------------------------------------- RawChainId
+/// [`ChainId`] in a format which can be stored in the DB.
+///
+/// Implements [`Into`] and [`From`] for [`ChainId`].
+///
+/// ```rust
+/// # use std::borrow::*;
+/// # use cuprate_blockchain::{*, types::*};
+/// use cuprate_database::Storable;
+/// use cuprate_types::ChainId;
+///
+/// // Assert Storable is correct.
+/// let a: RawChainId = ChainId(10.try_into().unwrap()).into();
+/// let b = Storable::as_bytes(&a);
+/// let c: RawChainId = Storable::from_bytes(b);
+/// assert_eq!(a, c);
+/// ```
+///
+/// # Size & Alignment
+/// ```rust
+/// # use cuprate_blockchain::types::*;
+/// assert_eq!(size_of::<RawChainId>(), 8);
+/// assert_eq!(align_of::<RawChainId>(), 8);
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Pod, Zeroable)]
+#[repr(transparent)]
+pub struct RawChainId(u64);
+
+impl From<ChainId> for RawChainId {
+    fn from(value: ChainId) -> Self {
+        Self(value.0.get())
+    }
+}
+
+impl From<RawChainId> for ChainId {
+    fn from(value: RawChainId) -> Self {
+        Self(NonZero::new(value.0).expect("RawChainId cannot have a value of `0`"))
+    }
+}
+
+impl Key for RawChainId {}
+
+//---------------------------------------------------------------------------------------------------- AltChainInfo
+/// Information on an alternative chain.
+///
+/// ```rust
+/// # use std::borrow::*;
+/// # use cuprate_blockchain::{*, types::*};
+/// use cuprate_database::Storable;
+/// use cuprate_types::Chain;
+///
+/// // Assert Storable is correct.
+/// let a: AltChainInfo = AltChainInfo {
+///     parent_chain: Chain::Main.into(),
+///     common_ancestor_height: 0,
+///     chain_height: 1,
+/// };
+/// let b = Storable::as_bytes(&a);
+/// let c: AltChainInfo = Storable::from_bytes(b);
+/// assert_eq!(a, c);
+/// ```
+///
+/// # Size & Alignment
+/// ```rust
+/// # use cuprate_blockchain::types::*;
+/// assert_eq!(size_of::<AltChainInfo>(), 24);
+/// assert_eq!(align_of::<AltChainInfo>(), 8);
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Pod, Zeroable)]
+#[repr(C)]
+pub struct AltChainInfo {
+    /// The chain this alt chain forks from.
+    pub parent_chain: RawChain,
+    /// The height of the first block we share with the parent chain.
+    pub common_ancestor_height: usize,
+    /// The chain height of the blocks in this alt chain.
+    pub chain_height: usize,
+}
+
+//---------------------------------------------------------------------------------------------------- AltBlockHeight
+/// Represents the height of a block on an alt-chain.
+///
+/// ```rust
+/// # use std::borrow::*;
+/// # use cuprate_blockchain::{*, types::*};
+/// use cuprate_database::Storable;
+/// use cuprate_types::ChainId;
+///
+/// // Assert Storable is correct.
+/// let a: AltBlockHeight = AltBlockHeight {
+///     chain_id: ChainId(1.try_into().unwrap()).into(),
+///     height: 1,
+/// };
+/// let b = Storable::as_bytes(&a);
+/// let c: AltBlockHeight = Storable::from_bytes(b);
+/// assert_eq!(a, c);
+/// ```
+///
+/// # Size & Alignment
+/// ```rust
+/// # use cuprate_blockchain::types::*;
+/// assert_eq!(size_of::<AltBlockHeight>(), 16);
+/// assert_eq!(align_of::<AltBlockHeight>(), 8);
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Pod, Zeroable)]
+#[repr(C)]
+pub struct AltBlockHeight {
+    /// The [`ChainId`] of the chain this alt block is on, in raw form.
+    pub chain_id: RawChainId,
+    /// The height of this alt-block.
+    pub height: usize,
+}
+
+impl Key for AltBlockHeight {}
+
+//---------------------------------------------------------------------------------------------------- CompactAltBlockInfo
+/// Represents information on an alt-chain.
+///
+/// ```rust
+/// # use std::borrow::*;
+/// # use cuprate_blockchain::{*, types::*};
+/// use cuprate_database::Storable;
+///
+/// // Assert Storable is correct.
+/// let a: CompactAltBlockInfo = CompactAltBlockInfo {
+///     block_hash: [1; 32],
+///     pow_hash: [2; 32],
+///     height: 10,
+///     weight: 20,
+///     long_term_weight: 30,
+///     cumulative_difficulty_low: 40,
+///     cumulative_difficulty_high: 50,
+/// };
+///     
+/// let b = Storable::as_bytes(&a);
+/// let c: CompactAltBlockInfo = Storable::from_bytes(b);
+/// assert_eq!(a, c);
+/// ```
+///
+/// # Size & Alignment
+/// ```rust
+/// # use cuprate_blockchain::types::*;
+/// assert_eq!(size_of::<CompactAltBlockInfo>(), 104);
+/// assert_eq!(align_of::<CompactAltBlockInfo>(), 8);
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Pod, Zeroable)]
+#[repr(C)]
+pub struct CompactAltBlockInfo {
+    /// The block's hash.
+    pub block_hash: [u8; 32],
+    /// The block's proof-of-work hash.
+    pub pow_hash: [u8; 32],
+    /// The block's height.
+    pub height: usize,
+    /// The adjusted block size, in bytes.
+    pub weight: usize,
+    /// The long term block weight, which is the weight factored in with previous block weights.
+    pub long_term_weight: usize,
+    /// The low 64 bits of the cumulative difficulty.
+    pub cumulative_difficulty_low: u64,
+    /// The high 64 bits of the cumulative difficulty.
+    pub cumulative_difficulty_high: u64,
+}
+
+//---------------------------------------------------------------------------------------------------- AltTransactionInfo
+/// Represents information on an alt transaction.
+///
+/// ```rust
+/// # use std::borrow::*;
+/// # use cuprate_blockchain::{*, types::*};
+/// use cuprate_database::Storable;
+///
+/// // Assert Storable is correct.
+/// let a: AltTransactionInfo = AltTransactionInfo {
+///     tx_weight: 1,
+///     fee: 6,
+///     tx_hash: [6; 32],
+/// };
+///     
+/// let b = Storable::as_bytes(&a);
+/// let c: AltTransactionInfo = Storable::from_bytes(b);
+/// assert_eq!(a, c);
+/// ```
+///
+/// # Size & Alignment
+/// ```rust
+/// # use cuprate_blockchain::types::*;
+/// assert_eq!(size_of::<AltTransactionInfo>(), 48);
+/// assert_eq!(align_of::<AltTransactionInfo>(), 8);
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Pod, Zeroable)]
+#[repr(C)]
+pub struct AltTransactionInfo {
+    /// The transaction's weight.
+    pub tx_weight: usize,
+    /// The transaction's total fees.
+    pub fee: u64,
+    /// The transaction's hash.
+    pub tx_hash: [u8; 32],
+}
+
 //---------------------------------------------------------------------------------------------------- Tests
 #[cfg(test)]
 mod test {

test-utils/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Boog900", "hinto-janai"]
 
 [dependencies]
 cuprate-types             = { path = "../types" }
-cuprate-helper            = { path = "../helper", features = ["map"] }
+cuprate-helper            = { path = "../helper", features = ["map", "tx"] }
 cuprate-wire              = { path = "../net/wire" }
 cuprate-p2p-core          = { path = "../p2p/p2p-core", features = ["borsh"] }
 
@@ -22,7 +22,6 @@ tokio                     = { workspace = true, features = ["full"] }
 tokio-util                = { workspace = true }
 serde                     = { workspace = true }
 serde_json                = { workspace = true }
-bytes                     = { workspace = true, features = ["std"] }
 tempfile                  = { workspace = true }
 paste                     = { workspace = true }
 borsh                     = { workspace = true, features = ["derive"]}
@@ -30,3 +29,6 @@ borsh                     = { workspace = true, features = ["derive"]}
 [dev-dependencies]
 hex               = { workspace = true }
 pretty_assertions = { workspace = true }
+
+[lints]
+workspace = true

test-utils/src/data/mod.rs

@@ -25,13 +25,11 @@
 //! let tx: VerifiedTransactionInformation = TX_V1_SIG0.clone();
 //! ```
 
-mod constants;
 pub use constants::{
     BLOCK_43BD1F, BLOCK_5ECB7E, BLOCK_BBD604, BLOCK_F91043, TX_2180A8, TX_3BC7FF, TX_84D48D,
     TX_9E3F73, TX_B6B439, TX_D7FEBD, TX_E2D393, TX_E57440,
 };
+pub use statics::{BLOCK_V16_TX0, BLOCK_V1_TX2, BLOCK_V9_TX3, TX_V1_SIG0, TX_V1_SIG2, TX_V2_RCT3};
 
+mod constants;
 mod statics;
-pub use statics::{
-    tx_fee, BLOCK_V16_TX0, BLOCK_V1_TX2, BLOCK_V9_TX3, TX_V1_SIG0, TX_V1_SIG2, TX_V2_RCT3,
-};

test-utils/src/data/statics.rs

@@ -8,12 +8,12 @@
 //---------------------------------------------------------------------------------------------------- Import
 use std::sync::LazyLock;
 
-use cuprate_helper::map::combine_low_high_bits_to_u128;
-use cuprate_types::{VerifiedBlockInformation, VerifiedTransactionInformation};
 use hex_literal::hex;
-use monero_serai::transaction::Input;
 use monero_serai::{block::Block, transaction::Transaction};
 
+use cuprate_helper::{map::combine_low_high_bits_to_u128, tx::tx_fee};
+use cuprate_types::{VerifiedBlockInformation, VerifiedTransactionInformation};
+
 use crate::data::constants::{
     BLOCK_43BD1F, BLOCK_5ECB7E, BLOCK_F91043, TX_2180A8, TX_3BC7FF, TX_84D48D, TX_9E3F73,
     TX_B6B439, TX_D7FEBD, TX_E2D393, TX_E57440,
@@ -110,36 +110,6 @@ fn to_tx_verification_data(tx_blob: impl AsRef<[u8]>) -> VerifiedTransactionInfo
     }
 }
 
-/// Calculates the fee of the [`Transaction`].
-///
-/// # Panics
-/// This will panic if the inputs overflow or the transaction outputs too much.
-pub fn tx_fee(tx: &Transaction) -> u64 {
-    let mut fee = 0_u64;
-
-    match &tx {
-        Transaction::V1 { prefix, .. } => {
-            for input in &prefix.inputs {
-                match input {
-                    Input::Gen(_) => return 0,
-                    Input::ToKey { amount, .. } => {
-                        fee = fee.checked_add(amount.unwrap_or(0)).unwrap();
-                    }
-                }
-            }
-
-            for output in &prefix.outputs {
-                fee.checked_sub(output.amount.unwrap_or(0)).unwrap();
-            }
-        }
-        Transaction::V2 { proofs, .. } => {
-            fee = proofs.as_ref().unwrap().base.fee;
-        }
-    };
-
-    fee
-}
-
 //---------------------------------------------------------------------------------------------------- Blocks
 /// Generate a `static LazyLock<VerifiedBlockInformation>`.
 ///
@@ -148,8 +118,8 @@ pub fn tx_fee(tx: &Transaction) -> u64 {
 ///
 /// This requires some static block/tx input (from data) and some fields.
 /// This data can be accessed more easily via:
-/// - A block explorer (https://xmrchain.net)
+/// - A block explorer (<https://xmrchain.net>)
-/// - Monero RPC (see cuprate_test_utils::rpc for this)
+/// - Monero RPC (see `cuprate_test_utils::rpc` for this)
 ///
 /// See below for actual usage.
 macro_rules! verified_block_information {
@@ -311,12 +281,12 @@ transaction_verification_data! {
 //---------------------------------------------------------------------------------------------------- TESTS
 #[cfg(test)]
 mod tests {
-    use super::*;
-
     use pretty_assertions::assert_eq;
 
     use crate::rpc::client::HttpRpcClient;
 
+    use super::*;
+
     /// Assert the defined blocks are the same compared to ones received from a local RPC call.
     #[ignore] // FIXME: doesn't work in CI, we need a real unrestricted node
     #[tokio::test]

test-utils/src/monerod.rs

@@ -178,6 +178,7 @@ impl Drop for SpawnedMoneroD {
             println!("------END-MONEROD-LOGS------");
         }
 
+        #[expect(clippy::manual_assert, reason = "`if` is more clear")]
         if error && !panicking() {
             // `println` only outputs in a test when panicking so if there is an error while
             // dropping monerod but not an error in the test then we need to panic to make sure

test-utils/src/rpc/client.rs

@@ -1,18 +1,16 @@
 //! HTTP RPC client.
 
 //---------------------------------------------------------------------------------------------------- Use
+use monero_rpc::Rpc;
+use monero_serai::block::Block;
+use monero_simple_request_rpc::SimpleRequestRpc;
 use serde::Deserialize;
 use serde_json::json;
 use tokio::task::spawn_blocking;
 
-use monero_rpc::Rpc;
+use cuprate_helper::tx::tx_fee;
-use monero_serai::block::Block;
-use monero_simple_request_rpc::SimpleRequestRpc;
-
 use cuprate_types::{VerifiedBlockInformation, VerifiedTransactionInformation};
 
-use crate::data::tx_fee;
-
 //---------------------------------------------------------------------------------------------------- Constants
 /// The default URL used for Monero RPC connections.
 pub const LOCALHOST_RPC_URL: &str = "http://127.0.0.1:18081";
@@ -47,13 +45,13 @@ impl HttpRpcClient {
     }
 
     /// The address used for this [`HttpRpcClient`].
-    #[allow(dead_code)]
+    #[allow(clippy::allow_attributes, dead_code, reason = "expect doesn't work")]
     const fn address(&self) -> &String {
         &self.address
     }
 
     /// Access to the inner RPC client for other usage.
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     const fn rpc(&self) -> &SimpleRequestRpc {
         &self.rpc
     }
@@ -184,9 +182,10 @@ impl HttpRpcClient {
 //---------------------------------------------------------------------------------------------------- TESTS
 #[cfg(test)]
 mod tests {
-    use super::*;
     use hex_literal::hex;
 
+    use super::*;
+
     /// Assert the default address is localhost.
     #[tokio::test]
     async fn localhost() {
@@ -197,7 +196,7 @@ mod tests {
     #[ignore] // FIXME: doesn't work in CI, we need a real unrestricted node
     #[tokio::test]
     async fn get() {
-        #[allow(clippy::too_many_arguments)]
+        #[expect(clippy::too_many_arguments)]
         async fn assert_eq(
             rpc: &HttpRpcClient,
             height: usize,

test-utils/src/rpc/data/macros.rs

@@ -156,13 +156,5 @@ macro_rules! define_request_and_response_doc_test {
             "```\n",
         )
     };
-
-    // No doc test.
-    (
-        $name:ident,
-        $test:ident,
-    ) => {
-        ""
-    };
 }
 pub(super) use define_request_and_response_doc_test;

test-utils/src/rpc/data/other.rs

@@ -8,8 +8,7 @@ define_request_and_response! {
     // `(other)` adds a JSON sanity-check test.
     get_height (other),
     GET_HEIGHT: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "hash": "68bb1a1cff8e2a44c3221e8e1aff80bc6ca45d06fa8eff4d2a3a7ac31d4efe3f",
@@ -53,8 +52,7 @@ r#"{
 define_request_and_response! {
     get_alt_blocks_hashes (other),
     GET_ALT_BLOCKS_HASHES: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "blks_hashes": ["8ee10db35b1baf943f201b303890a29e7d45437bd76c2bd4df0d2f2ee34be109"],
@@ -134,8 +132,7 @@ r#"{
 define_request_and_response! {
     stop_mining (other),
     STOP_MINING: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "status": "OK",
@@ -146,8 +143,7 @@ r#"{
 define_request_and_response! {
     mining_status (other),
     MINING_STATUS: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "active": false,
@@ -173,8 +169,7 @@ r#"{
 define_request_and_response! {
     save_bc (other),
     SAVE_BC: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "status": "OK",
@@ -185,8 +180,7 @@ r#"{
 define_request_and_response! {
     get_peer_list (other),
     GET_PEER_LIST: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "gray_list": [{
@@ -291,8 +285,7 @@ r#"{
 define_request_and_response! {
     get_transaction_pool (other),
     GET_TRANSACTION_POOL: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "credits": 0,
@@ -598,8 +591,7 @@ r#"{
 define_request_and_response! {
     get_transaction_pool_stats (other),
     GET_TRANSACTION_POOL_STATS: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "credits": 0,
@@ -657,8 +649,7 @@ r#"{
 define_request_and_response! {
     stop_daemon (other),
     STOP_DAEMON: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "status": "OK"
@@ -668,8 +659,7 @@ r#"{
 define_request_and_response! {
     get_limit (other),
     GET_LIMIT: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "limit_down": 1280000,
@@ -713,8 +703,7 @@ r#"{
 define_request_and_response! {
     get_net_stats (other),
     GET_NET_STATS: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "start_time": 1721251858,
@@ -801,8 +790,7 @@ r#"{
 define_request_and_response! {
     UNDOCUMENTED_ENDPOINT (other),
     GET_TRANSACTION_POOL_HASHES: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "credits": 0,
@@ -835,8 +823,7 @@ r#"{
 define_request_and_response! {
     UNDOCUMENTED_ENDPOINT (other),
     GET_PUBLIC_NODES: &str,
-    Request =
+    Request = "{}";
-r#"{}"#;
     Response =
 r#"{
   "status": "OK",

test-utils/src/test_netzone.rs

@@ -86,9 +86,8 @@ impl<const ALLOW_SYNC: bool, const DANDELION_PP: bool, const CHECK_NODE_ID: bool
     type Sink = FramedWrite<WriteHalf<DuplexStream>, MoneroWireCodec>;
     type Listener = Pin<
         Box<
-            dyn Stream<
+            dyn Stream<Item = Result<(Option<Self::Addr>, Self::Stream, Self::Sink), Error>>
-                    Item = Result<(Option<Self::Addr>, Self::Stream, Self::Sink), std::io::Error>,
+                + Send
-                > + Send
                 + 'static,
         >,
     >;

types/src/blockchain.rs

@@ -2,14 +2,16 @@
 //!
 //! Tests that assert particular requests lead to particular
 //! responses are also tested in Cuprate's blockchain database crate.
-
 //---------------------------------------------------------------------------------------------------- Import
 use std::{
     collections::{HashMap, HashSet},
     ops::Range,
 };
 
-use crate::types::{Chain, ExtendedBlockHeader, OutputOnChain, VerifiedBlockInformation};
+use crate::{
+    types::{Chain, ExtendedBlockHeader, OutputOnChain, VerifiedBlockInformation},
+    AltBlockInformation, ChainId,
+};
 
 //---------------------------------------------------------------------------------------------------- ReadRequest
 /// A read request to the blockchain database.
@@ -92,26 +94,49 @@ pub enum BlockchainReadRequest {
     CompactChainHistory,
 
     /// A request to find the first unknown block ID in a list of block IDs.
-    ////
+    ///
     /// # Invariant
     /// The [`Vec`] containing the block IDs must be sorted in chronological block
     /// order, or else the returned response is unspecified and meaningless,
     /// as this request performs a binary search.
     FindFirstUnknown(Vec<[u8; 32]>),
+
+    /// A request for all alt blocks in the chain with the given [`ChainId`].
+    AltBlocksInChain(ChainId),
 }
 
 //---------------------------------------------------------------------------------------------------- WriteRequest
 /// A write request to the blockchain database.
-///
-/// There is currently only 1 write request to the database,
-/// as such, the only valid [`BlockchainResponse`] to this request is
-/// the proper response for a [`BlockchainResponse::WriteBlockOk`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BlockchainWriteRequest {
     /// Request that a block be written to the database.
     ///
     /// Input is an already verified block.
     WriteBlock(VerifiedBlockInformation),
+
+    /// Write an alternative block to the database,
+    ///
+    /// Input is the alternative block.
+    WriteAltBlock(AltBlockInformation),
+
+    /// A request to pop some blocks from the top of the main chain
+    ///
+    /// Input is the amount of blocks to pop.
+    ///
+    /// This request flushes all alt-chains from the cache before adding the popped blocks to the
+    /// alt cache.
+    PopBlocks(usize),
+
+    /// A request to reverse the re-org process.
+    ///
+    /// The inner value is the [`ChainId`] of the old main chain.
+    ///
+    /// # Invariant
+    /// It is invalid to call this with a [`ChainId`] that was not returned from [`BlockchainWriteRequest::PopBlocks`].
+    ReverseReorg(ChainId),
+
+    /// A request to flush all alternative blocks.
+    FlushAltBlocks,
 }
 
 //---------------------------------------------------------------------------------------------------- Response
@@ -197,12 +222,24 @@ pub enum BlockchainResponse {
     /// This will be [`None`] if all blocks were known.
     FindFirstUnknown(Option<(usize, usize)>),
 
-    //------------------------------------------------------ Writes
+    /// The response for [`BlockchainReadRequest::AltBlocksInChain`].
-    /// Response to [`BlockchainWriteRequest::WriteBlock`].
     ///
-    /// This response indicates that the requested block has
+    /// Contains all the alt blocks in the alt-chain in chronological order.
-    /// successfully been written to the database without error.
+    AltBlocksInChain(Vec<AltBlockInformation>),
-    WriteBlockOk,
+
+    //------------------------------------------------------ Writes
+    /// A generic Ok response to indicate a request was successfully handled.
+    ///
+    /// currently the response for:
+    /// - [`BlockchainWriteRequest::WriteBlock`]
+    /// - [`BlockchainWriteRequest::WriteAltBlock`]
+    /// - [`BlockchainWriteRequest::ReverseReorg`]
+    /// - [`BlockchainWriteRequest::FlushAltBlocks`]
+    Ok,
+    /// The response for [`BlockchainWriteRequest::PopBlocks`].
+    ///
+    /// The inner value is the alt-chain ID for the old main chain blocks.
+    PopBlocks(ChainId),
 }
 
 //---------------------------------------------------------------------------------------------------- Tests

types/src/types.rs

@@ -1,6 +1,8 @@
 //! Various shared data types in Cuprate.
 
 //---------------------------------------------------------------------------------------------------- Import
+use std::num::NonZero;
+
 use curve25519_dalek::edwards::EdwardsPoint;
 use monero_serai::{
     block::Block,
@@ -38,8 +40,7 @@ pub struct ExtendedBlockHeader {
 //---------------------------------------------------------------------------------------------------- VerifiedTransactionInformation
 /// Verified information of a transaction.
 ///
-/// - If this is in a [`VerifiedBlockInformation`] this represents a valid transaction
+/// This represents a valid transaction
-/// - If this is in an [`AltBlockInformation`] this represents a potentially valid transaction
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct VerifiedTransactionInformation {
     /// The transaction itself.
@@ -79,6 +80,7 @@ pub struct VerifiedBlockInformation {
     /// [`Block::hash`].
     pub block_hash: [u8; 32],
     /// The block's proof-of-work hash.
+    // TODO: make this an option.
     pub pow_hash: [u8; 32],
     /// The block's height.
     pub height: usize,
@@ -97,7 +99,7 @@ pub struct VerifiedBlockInformation {
 ///
 /// The inner value is meaningless.
 #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct ChainId(pub u64);
+pub struct ChainId(pub NonZero<u64>);
 
 //---------------------------------------------------------------------------------------------------- Chain
 /// An identifier for a chain.