cuprated/rpc: add JsonFormatter

binaries/cuprated/src/config/rpc.rs

@@ -5,6 +5,8 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
+use cuprate_rpc_interface::JsonFormatter;
+
 use crate::config::macros::config_struct;
 
 config_struct! {
@@ -39,6 +41,34 @@ config_struct! {
         /// Examples | true, false
         pub enable: bool,
 
+        /// Adjust the JSON output formatting.
+        ///
+        /// The default formatting is:
+        /// - "Compact" for restricted RPC
+        /// - "Pretty" for unrestricted RPC
+        ///
+        /// "Compact" example:
+        /// ```
+        /// {"jsonrpc":"2.0","id":"0","result":{"status":"OK","untrusted":false,"count":3423276}}
+        /// ```
+        ///
+        /// "Pretty" example:
+        /// ```
+        /// {
+        ///   "jsonrpc": "2.0",
+        ///   "id": "0",
+        ///   "result": {
+        ///     "status": "OK",
+        ///     "untrusted": false,
+        ///     "count": 3423276
+        ///   }
+        /// }
+        /// ```
+        ///
+        /// Type         | Number
+        /// Valid values | "Compact", "Pretty"
+        pub json_formatter: JsonFormatter,
+
         #[comment_out = true]
         /// If a request is above this byte limit, it will be rejected.
         ///
@@ -91,6 +121,7 @@ impl Default for UnrestrictedRpcConfig {
             address: SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 18081)),
             enable: true,
             request_byte_limit: 0,
+            json_formatter: JsonFormatter::Pretty,
         }
     }
 }
@@ -104,6 +135,7 @@ impl Default for RestrictedRpcConfig {
             // 1 megabyte.
             // <https://github.com/monero-project/monero/blob/3b01c490953fe92f3c6628fa31d280a4f0490d28/src/cryptonote_config.h#L134>
             request_byte_limit: 1024 * 1024,
+            json_formatter: JsonFormatter::Compact,
         }
     }
 }

binaries/cuprated/src/main.rs

@@ -133,7 +133,7 @@ fn main() {
         let tx_handler = IncomingTxHandler::init(
             network_interfaces.clearnet_network_interface.clone(),
             txpool_write_handle.clone(),
-            txpool_read_handle,
+            txpool_read_handle.clone(),
             context_svc.clone(),
             blockchain_read_handle.clone(),
         );
@@ -149,15 +149,20 @@ fn main() {
         blockchain::init_blockchain_manager(
             network_interfaces.clearnet_network_interface,
             blockchain_write_handle,
-            blockchain_read_handle,
-            txpool_write_handle,
+            blockchain_read_handle.clone(),
+            txpool_write_handle.clone(),
             context_svc.clone(),
             config.block_downloader_config(),
         )
         .await;
 
         // Initialize the RPC server(s).
-        rpc::init_rpc_servers(config.rpc);
+        rpc::init_rpc_servers(
+            config.rpc,
+            blockchain_read_handle,
+            context_svc.clone(),
+            txpool_read_handle,
+        );
 
         // Start the command listener.
         if std::io::IsTerminal::is_terminal(&std::io::stdin()) {

binaries/cuprated/src/rpc/handlers/bin.rs

@@ -30,7 +30,7 @@ use cuprate_types::{
 };
 
 use crate::rpc::{
-    handlers::{helper, shared},
+    handlers::{helper, shared, shared::not_available},
     service::{blockchain, txpool},
     CupratedRpcHandler,
 };
@@ -44,17 +44,13 @@ pub async fn map_request(
     use BinResponse as Resp;
 
     Ok(match request {
-        Req::GetBlocks(r) => Resp::GetBlocks(get_blocks(state, r).await?),
-        Req::GetBlocksByHeight(r) => Resp::GetBlocksByHeight(get_blocks_by_height(state, r).await?),
-        Req::GetHashes(r) => Resp::GetHashes(get_hashes(state, r).await?),
-        Req::GetOutputIndexes(r) => Resp::GetOutputIndexes(get_output_indexes(state, r).await?),
-        Req::GetOuts(r) => Resp::GetOuts(get_outs(state, r).await?),
-        Req::GetTransactionPoolHashes(r) => {
-            Resp::GetTransactionPoolHashes(get_transaction_pool_hashes(state, r).await?)
-        }
-        Req::GetOutputDistribution(r) => {
-            Resp::GetOutputDistribution(get_output_distribution(state, r).await?)
-        }
+        Req::GetBlocks(r) => Resp::GetBlocks(not_available()?),
+        Req::GetBlocksByHeight(r) => Resp::GetBlocksByHeight(not_available()?),
+        Req::GetHashes(r) => Resp::GetHashes(not_available()?),
+        Req::GetOutputIndexes(r) => Resp::GetOutputIndexes(not_available()?),
+        Req::GetOuts(r) => Resp::GetOuts(not_available()?),
+        Req::GetTransactionPoolHashes(r) => Resp::GetTransactionPoolHashes(not_available()?),
+        Req::GetOutputDistribution(r) => Resp::GetOutputDistribution(not_available()?),
     })
 }
 

binaries/cuprated/src/rpc/handlers/helper.rs

@@ -15,7 +15,7 @@ use cuprate_rpc_types::{
     base::{AccessResponseBase, ResponseBase},
     misc::BlockHeader,
 };
-use cuprate_types::HardFork;
+use cuprate_types::{Chain, HardFork};
 use monero_serai::transaction::Timelock;
 
 use crate::rpc::{
@@ -58,15 +58,17 @@ pub(super) async fn block_header(
         let seed_hash = blockchain::block_hash(
             &mut state.blockchain_read,
             height,
-            todo!("access to `cuprated`'s Chain"),
+            // TODO: access to `cuprated`'s Chain
+            Chain::Main,
         )
         .await?;
 
         Some(
             blockchain_context::calculate_pow(
                 &mut state.blockchain_context,
                 hardfork,
-                block,
+                // TODO: expensive clone
+                block.clone(),
                 seed_hash,
             )
             .await?,

binaries/cuprated/src/rpc/handlers/json_rpc.rs

@@ -61,7 +61,7 @@ use crate::{
     constants::VERSION_BUILD,
     rpc::{
         constants::{FIELD_NOT_SUPPORTED, UNSUPPORTED_RPC_CALL},
-        handlers::{helper, shared},
+        handlers::{helper, shared, shared::not_available},
         service::{address_book, blockchain, blockchain_context, blockchain_manager, txpool},
         CupratedRpcHandler,
     },
@@ -77,11 +77,11 @@ pub async fn map_request(
     use JsonRpcResponse as Resp;
 
     Ok(match request {
-        Req::GetBlockTemplate(r) => Resp::GetBlockTemplate(get_block_template(state, r).await?),
+        Req::GetBlockTemplate(r) => Resp::GetBlockTemplate(not_available()?),
         Req::GetBlockCount(r) => Resp::GetBlockCount(get_block_count(state, r).await?),
         Req::OnGetBlockHash(r) => Resp::OnGetBlockHash(on_get_block_hash(state, r).await?),
-        Req::SubmitBlock(r) => Resp::SubmitBlock(submit_block(state, r).await?),
-        Req::GenerateBlocks(r) => Resp::GenerateBlocks(generate_blocks(state, r).await?),
+        Req::SubmitBlock(r) => Resp::SubmitBlock(not_available()?),
+        Req::GenerateBlocks(r) => Resp::GenerateBlocks(not_available()?),
         Req::GetLastBlockHeader(r) => {
             Resp::GetLastBlockHeader(get_last_block_header(state, r).await?)
         }
@@ -95,33 +95,25 @@ pub async fn map_request(
             Resp::GetBlockHeadersRange(get_block_headers_range(state, r).await?)
         }
         Req::GetBlock(r) => Resp::GetBlock(get_block(state, r).await?),
-        Req::GetConnections(r) => Resp::GetConnections(get_connections(state, r).await?),
-        Req::GetInfo(r) => Resp::GetInfo(get_info(state, r).await?),
-        Req::HardForkInfo(r) => Resp::HardForkInfo(hard_fork_info(state, r).await?),
-        Req::SetBans(r) => Resp::SetBans(set_bans(state, r).await?),
-        Req::GetBans(r) => Resp::GetBans(get_bans(state, r).await?),
-        Req::Banned(r) => Resp::Banned(banned(state, r).await?),
-        Req::FlushTransactionPool(r) => {
-            Resp::FlushTransactionPool(flush_transaction_pool(state, r).await?)
-        }
-        Req::GetOutputHistogram(r) => {
-            Resp::GetOutputHistogram(get_output_histogram(state, r).await?)
-        }
-        Req::GetCoinbaseTxSum(r) => Resp::GetCoinbaseTxSum(get_coinbase_tx_sum(state, r).await?),
-        Req::GetVersion(r) => Resp::GetVersion(get_version(state, r).await?),
-        Req::GetFeeEstimate(r) => Resp::GetFeeEstimate(get_fee_estimate(state, r).await?),
-        Req::GetAlternateChains(r) => {
-            Resp::GetAlternateChains(get_alternate_chains(state, r).await?)
-        }
-        Req::RelayTx(r) => Resp::RelayTx(relay_tx(state, r).await?),
-        Req::SyncInfo(r) => Resp::SyncInfo(sync_info(state, r).await?),
-        Req::GetTransactionPoolBacklog(r) => {
-            Resp::GetTransactionPoolBacklog(get_transaction_pool_backlog(state, r).await?)
-        }
-        Req::GetMinerData(r) => Resp::GetMinerData(get_miner_data(state, r).await?),
-        Req::PruneBlockchain(r) => Resp::PruneBlockchain(prune_blockchain(state, r).await?),
-        Req::CalcPow(r) => Resp::CalcPow(calc_pow(state, r).await?),
-        Req::AddAuxPow(r) => Resp::AddAuxPow(add_aux_pow(state, r).await?),
+        Req::GetConnections(r) => Resp::GetConnections(not_available()?),
+        Req::GetInfo(r) => Resp::GetInfo(not_available()?),
+        Req::HardForkInfo(r) => Resp::HardForkInfo(not_available()?),
+        Req::SetBans(r) => Resp::SetBans(not_available()?),
+        Req::GetBans(r) => Resp::GetBans(not_available()?),
+        Req::Banned(r) => Resp::Banned(not_available()?),
+        Req::FlushTransactionPool(r) => Resp::FlushTransactionPool(not_available()?),
+        Req::GetOutputHistogram(r) => Resp::GetOutputHistogram(not_available()?),
+        Req::GetCoinbaseTxSum(r) => Resp::GetCoinbaseTxSum(not_available()?),
+        Req::GetVersion(r) => Resp::GetVersion(not_available()?),
+        Req::GetFeeEstimate(r) => Resp::GetFeeEstimate(not_available()?),
+        Req::GetAlternateChains(r) => Resp::GetAlternateChains(not_available()?),
+        Req::RelayTx(r) => Resp::RelayTx(not_available()?),
+        Req::SyncInfo(r) => Resp::SyncInfo(not_available()?),
+        Req::GetTransactionPoolBacklog(r) => Resp::GetTransactionPoolBacklog(not_available()?),
+        Req::GetMinerData(r) => Resp::GetMinerData(not_available()?),
+        Req::PruneBlockchain(r) => Resp::PruneBlockchain(not_available()?),
+        Req::CalcPow(r) => Resp::CalcPow(not_available()?),
+        Req::AddAuxPow(r) => Resp::AddAuxPow(not_available()?),
 
         // Unsupported RPC calls.
         Req::GetTxIdsLoose(_) | Req::FlushCache(_) => return Err(anyhow!(UNSUPPORTED_RPC_CALL)),
@@ -172,7 +164,7 @@ async fn get_block_template(
         seed_hash,
         next_seed_hash,
     } = *blockchain_manager::create_block_template(
-        &mut state.blockchain_manager,
+        todo!(),
         prev_block,
         request.wallet_address,
         request.extra_nonce.0,
@@ -242,7 +234,7 @@ async fn submit_block(
     let block_id = Hex(block.hash());
 
     // Attempt to relay the block.
-    blockchain_manager::relay_block(&mut state.blockchain_manager, Box::new(block)).await?;
+    blockchain_manager::relay_block(todo!(), Box::new(block)).await?;
 
     Ok(SubmitBlockResponse {
         base: helper::response_base(false),
@@ -269,7 +261,7 @@ async fn generate_blocks(
     };
 
     let (blocks, height) = blockchain_manager::generate_blocks(
-        &mut state.blockchain_manager,
+        todo!(),
         request.amount_of_blocks,
         prev_block,
         request.starting_nonce,
@@ -479,7 +471,7 @@ async fn get_info(
         (String::new(), false)
     };
 
-    let busy_syncing = blockchain_manager::syncing(&mut state.blockchain_manager).await?;
+    let busy_syncing = blockchain_manager::syncing(todo!()).await?;
 
     let (cumulative_difficulty, cumulative_difficulty_top64) =
         split_u128_into_low_high_bits(cumulative_difficulty);
@@ -524,12 +516,10 @@ async fn get_info(
     let rpc_connections_count = if restricted { 0 } else { 0 };
 
     let start_time = if restricted { 0 } else { *START_INSTANT_UNIX };
-    let synchronized = blockchain_manager::synced(&mut state.blockchain_manager).await?;
+    let synchronized = blockchain_manager::synced(todo!()).await?;
 
-    let target_height = blockchain_manager::target_height(&mut state.blockchain_manager).await?;
-    let target = blockchain_manager::target(&mut state.blockchain_manager)
-        .await?
-        .as_secs();
+    let target_height = blockchain_manager::target_height(todo!()).await?;
+    let target = blockchain_manager::target(todo!()).await?.as_secs();
     let top_block_hash = Hex(c.top_hash);
 
     let tx_count = blockchain::total_tx_count(&mut state.blockchain_read).await?;
@@ -738,7 +728,7 @@ async fn flush_transaction_pool(
         .map(|h| h.0)
         .collect::<Vec<[u8; 32]>>();
 
-    txpool::flush(&mut state.txpool_manager, tx_hashes).await?;
+    txpool::flush(todo!(), tx_hashes).await?;
 
     Ok(FlushTransactionPoolResponse { status: Status::Ok })
 }
@@ -807,7 +797,7 @@ async fn get_version(
     _: GetVersionRequest,
 ) -> Result<GetVersionResponse, Error> {
     let current_height = helper::top_height(&mut state).await?.0;
-    let target_height = blockchain_manager::target_height(&mut state.blockchain_manager).await?;
+    let target_height = blockchain_manager::target_height(todo!()).await?;
 
     let mut hard_forks = Vec::with_capacity(HardFork::COUNT);
 
@@ -880,7 +870,7 @@ async fn relay_tx(
         .map(|h| h.0)
         .collect::<Vec<[u8; 32]>>();
 
-    txpool::relay(&mut state.txpool_manager, tx_hashes).await?;
+    txpool::relay(todo!(), tx_hashes).await?;
 
     Ok(RelayTxResponse { status: Status::Ok })
 }
@@ -892,20 +882,19 @@ async fn sync_info(
 ) -> Result<SyncInfoResponse, Error> {
     let height = usize_to_u64(state.blockchain_context.blockchain_context().chain_height);
 
-    let target_height = blockchain_manager::target_height(&mut state.blockchain_manager).await?;
+    let target_height = blockchain_manager::target_height(todo!()).await?;
 
     let peers = address_book::connection_info::<ClearNet>(&mut DummyAddressBook)
         .await?
         .into_iter()
         .map(|info| SyncInfoPeer { info })
         .collect();
 
-    let next_needed_pruning_seed =
-        blockchain_manager::next_needed_pruning_seed(&mut state.blockchain_manager)
-            .await?
-            .compress();
+    let next_needed_pruning_seed = blockchain_manager::next_needed_pruning_seed(todo!())
+        .await?
+        .compress();
 
-    let spans = blockchain_manager::spans::<ClearNet>(&mut state.blockchain_manager).await?;
+    let spans = blockchain_manager::spans::<ClearNet>(todo!()).await?;
 
     // <https://github.com/Cuprate/cuprate/pull/320#discussion_r1811063772>
     let overview = String::from(FIELD_NOT_SUPPORTED);
@@ -994,10 +983,8 @@ async fn prune_blockchain(
     mut state: CupratedRpcHandler,
     request: PruneBlockchainRequest,
 ) -> Result<PruneBlockchainResponse, Error> {
-    let pruned = blockchain_manager::pruned(&mut state.blockchain_manager).await?;
-    let pruning_seed = blockchain_manager::prune(&mut state.blockchain_manager)
-        .await?
-        .compress();
+    let pruned = blockchain_manager::pruned(todo!()).await?;
+    let pruning_seed = blockchain_manager::prune(todo!()).await?.compress();
 
     Ok(PruneBlockchainResponse {
         base: helper::response_base(false),