cuprated: RPC handlers (json-rpc)

binaries/cuprated/Cargo.toml

@@ -13,7 +13,7 @@ cuprate-consensus         = { workspace = true }
 cuprate-fast-sync         = { workspace = true }
 cuprate-consensus-context = { workspace = true }
 cuprate-consensus-rules   = { workspace = true }
-cuprate-constants         = { workspace = true }
+cuprate-constants         = { workspace = true, features = ["build", "rpc"] }
 cuprate-cryptonight       = { workspace = true }
 cuprate-helper            = { workspace = true }
 cuprate-epee-encoding     = { workspace = true }
@@ -31,7 +31,7 @@ cuprate-txpool            = { workspace = true }
 cuprate-database          = { workspace = true }
 cuprate-pruning           = { workspace = true }
 cuprate-test-utils        = { workspace = true }
-cuprate-types             = { workspace = true }
+cuprate-types             = { workspace = true, features = ["json"] }
 cuprate-json-rpc          = { workspace = true }
 cuprate-rpc-interface     = { workspace = true }
 cuprate-rpc-types         = { workspace = true }
@@ -66,6 +66,7 @@ rayon                 = { workspace = true }
 serde_bytes           = { workspace = true }
 serde_json            = { workspace = true }
 serde                 = { workspace = true }
+strum                 = { workspace = true }
 thiserror             = { workspace = true }
 thread_local          = { workspace = true }
 tokio-util            = { workspace = true }

binaries/cuprated/src/rpc.rs

@@ -5,6 +5,7 @@
 mod bin;
 mod constants;
 mod handler;
+mod helper;
 mod json;
 mod other;
 mod request;

binaries/cuprated/src/rpc/bin.rs

@@ -1,3 +1,5 @@
+//! RPC request handler functions (binary endpoints).
+
 use anyhow::Error;
 
 use cuprate_rpc_types::{

binaries/cuprated/src/rpc/handler.rs

@@ -1,4 +1,4 @@
-//! Dummy implementation of [`RpcHandler`].
+//! `cuprated`'s implementation of [`RpcHandler`].
 
 use std::task::{Context, Poll};
 
@@ -7,7 +7,7 @@ use futures::future::BoxFuture;
 use monero_serai::block::Block;
 use tower::Service;
 
-use cuprate_blockchain::service::{BlockchainReadHandle, BlockchainWriteHandle};
+use cuprate_blockchain::service::BlockchainReadHandle;
 use cuprate_consensus::BlockChainContextService;
 use cuprate_pruning::PruningSeed;
 use cuprate_rpc_interface::RpcHandler;
@@ -16,14 +16,12 @@ use cuprate_rpc_types::{
     json::{JsonRpcRequest, JsonRpcResponse},
     other::{OtherRequest, OtherResponse},
 };
-use cuprate_txpool::service::{TxpoolReadHandle, TxpoolWriteHandle};
-use cuprate_types::{AddAuxPow, AuxPow, HardFork};
+use cuprate_txpool::service::TxpoolReadHandle;
 
 use crate::rpc::{bin, json, other};
 
 /// TODO: use real type when public.
 #[derive(Clone)]
-#[expect(clippy::large_enum_variant)]
 pub enum BlockchainManagerRequest {
     /// Pop blocks off the top of the blockchain.
     ///
@@ -37,7 +35,10 @@ pub enum BlockchainManagerRequest {
     Pruned,
 
     /// Relay a block to the network.
-    RelayBlock(Block),
+    RelayBlock(
+        /// This is [`Box`]ed due to `clippy::large_enum_variant`.
+        Box<Block>,
+    ),
 
     /// Is the blockchain in the middle of syncing?
     ///
@@ -139,7 +140,7 @@ pub type BlockchainManagerHandle = cuprate_database_service::DatabaseReadService
 /// TODO
 #[derive(Clone)]
 pub struct CupratedRpcHandler {
-    /// Should this RPC server be [restricted](RpcHandler::restricted)?
+    /// Should this RPC server be [restricted](RpcHandler::is_restricted)?
     ///
     /// This is not `pub` on purpose, as it should not be mutated after [`Self::new`].
     restricted: bool,
@@ -182,7 +183,7 @@ impl CupratedRpcHandler {
 }
 
 impl RpcHandler for CupratedRpcHandler {
-    fn restricted(&self) -> bool {
+    fn is_restricted(&self) -> bool {
         self.restricted
     }
 }

binaries/cuprated/src/rpc/helper.rs

@@ -0,0 +1,186 @@
+//! These are internal helper functions used by the actual RPC handlers.
+//!
+//! Many of the handlers have bodies with only small differences,
+//! the identical code is extracted and reused here in these functions.
+//!
+//! These build on-top of [`crate::rpc::request`] functions.
+
+use anyhow::{anyhow, Error};
+
+use cuprate_helper::{
+    cast::{u64_to_usize, usize_to_u64},
+    map::split_u128_into_low_high_bits,
+};
+use cuprate_rpc_types::misc::{BlockHeader, KeyImageSpentStatus};
+use cuprate_types::HardFork;
+
+use crate::{
+    rpc::request::{blockchain, blockchain_context},
+    rpc::CupratedRpcHandler,
+};
+
+/// Map some data into a [`BlockHeader`].
+///
+/// Sort of equivalent to:
+/// <https://github.com/monero-project/monero/blob/893916ad091a92e765ce3241b94e706ad012b62a/src/rpc/core_rpc_server.cpp#L2361>.
+pub(super) async fn block_header(
+    state: &mut CupratedRpcHandler,
+    height: u64,
+    fill_pow_hash: bool,
+) -> Result<BlockHeader, Error> {
+    let block = blockchain::block(&mut state.blockchain_read, height).await?;
+    let header = blockchain::block_extended_header(&mut state.blockchain_read, height).await?;
+    let hardfork = HardFork::from_vote(header.vote);
+    let (top_height, _) = top_height(state).await?;
+
+    // TODO: if the request block is not on the main chain,
+    // we must get the alt block and this variable will be `true`.
+    let orphan_status = false;
+
+    // FIXME: is there a cheaper way to get this?
+    let difficulty = blockchain_context::batch_get_difficulties(
+        &mut state.blockchain_context,
+        vec![(height, hardfork)],
+    )
+    .await?
+    .first()
+    .copied()
+    .ok_or_else(|| anyhow!("Failed to get block difficulty"))?;
+
+    let pow_hash = if fill_pow_hash {
+        let seed_height =
+            cuprate_consensus_rules::blocks::randomx_seed_height(u64_to_usize(height));
+        let seed_hash = blockchain::block_hash(
+            &mut state.blockchain_read,
+            height,
+            todo!("access to `cuprated`'s Chain"),
+        )
+        .await?;
+
+        let pow_hash = blockchain_context::calculate_pow(
+            &mut state.blockchain_context,
+            hardfork,
+            block,
+            seed_hash,
+        )
+        .await?;
+
+        hex::encode(pow_hash)
+    } else {
+        String::new()
+    };
+
+    let block_weight = usize_to_u64(header.block_weight);
+    let depth = top_height.saturating_sub(height);
+
+    let (cumulative_difficulty_top64, cumulative_difficulty) =
+        split_u128_into_low_high_bits(header.cumulative_difficulty);
+    let (difficulty_top64, difficulty) = split_u128_into_low_high_bits(difficulty);
+    let wide_difficulty = hex::encode(difficulty.to_ne_bytes());
+
+    let reward = block
+        .miner_transaction
+        .prefix()
+        .outputs
+        .iter()
+        .map(|o| o.amount.expect("coinbase is transparent"))
+        .sum::<u64>();
+
+    Ok(BlockHeader {
+        block_size: block_weight,
+        block_weight,
+        cumulative_difficulty_top64,
+        cumulative_difficulty,
+        depth,
+        difficulty_top64,
+        difficulty,
+        hash: hex::encode(block.hash()),
+        height,
+        long_term_weight: usize_to_u64(header.long_term_weight),
+        major_version: header.version.as_u8(),
+        miner_tx_hash: hex::encode(block.miner_transaction.hash()),
+        minor_version: header.vote,
+        nonce: block.header.nonce,
+        num_txes: usize_to_u64(block.transactions.len()),
+        orphan_status,
+        pow_hash,
+        prev_hash: hex::encode(block.header.previous),
+        reward,
+        timestamp: block.header.timestamp,
+        wide_cumulative_difficulty: hex::encode(u128::to_le_bytes(header.cumulative_difficulty)),
+        wide_difficulty,
+    })
+}
+
+/// Same as [`block_header`] but with the block's hash.
+pub(super) async fn block_header_by_hash(
+    state: &mut CupratedRpcHandler,
+    hash: [u8; 32],
+    fill_pow_hash: bool,
+) -> Result<BlockHeader, Error> {
+    let (_, height) = blockchain::find_block(&mut state.blockchain_read, hash)
+        .await?
+        .ok_or_else(|| anyhow!("Block did not exist."))?;
+
+    let block_header = block_header(state, usize_to_u64(height), fill_pow_hash).await?;
+
+    Ok(block_header)
+}
+
+/// Check if `height` is greater than the [`top_height`].
+///
+/// # Errors
+/// This returns the [`top_height`] on [`Ok`] and
+/// returns [`Error`] if `height` is greater than [`top_height`].
+pub(super) async fn check_height(
+    state: &mut CupratedRpcHandler,
+    height: u64,
+) -> Result<u64, Error> {
+    let (top_height, _) = top_height(state).await?;
+
+    if height > top_height {
+        return Err(anyhow!(
+            "Requested block height: {height} greater than top block height: {top_height}",
+        ));
+    }
+
+    Ok(top_height)
+}
+
+/// Parse a hexadecimal [`String`] as a 32-byte hash.
+#[expect(clippy::needless_pass_by_value)]
+pub(super) fn hex_to_hash(hex: String) -> Result<[u8; 32], Error> {
+    let error = || anyhow!("Failed to parse hex representation of hash. Hex = {hex}.");
+
+    let Ok(bytes) = hex::decode(&hex) else {
+        return Err(error());
+    };
+
+    let Ok(hash) = bytes.try_into() else {
+        return Err(error());
+    };
+
+    Ok(hash)
+}
+
+/// [`cuprate_types::blockchain::BlockchainResponse::ChainHeight`] minus 1.
+pub(super) async fn top_height(state: &mut CupratedRpcHandler) -> Result<(u64, [u8; 32]), Error> {
+    let (chain_height, hash) = blockchain::chain_height(&mut state.blockchain_read).await?;
+    let height = chain_height.saturating_sub(1);
+    Ok((height, hash))
+}
+
+/// Check if a key image is spent.
+pub(super) async fn key_image_spent(
+    state: &mut CupratedRpcHandler,
+    key_image: [u8; 32],
+) -> Result<KeyImageSpentStatus, Error> {
+    todo!("impl key image vec check responding KeyImageSpentStatus")
+    // if blockchain::key_image_spent(state, key_image).await? {
+    //     Ok(KeyImageSpentStatus::SpentInBlockchain)
+    // } else if todo!("key image is spent in tx pool") {
+    //     Ok(KeyImageSpentStatus::SpentInPool)
+    // } else {
+    //     Ok(KeyImageSpentStatus::Unspent)
+    // }
+}