clippy

binaries/cuprated/src/rpc.rs

@@ -9,5 +9,6 @@ mod helper;
 mod json;
 mod other;
 mod request;
+mod shared;
 
 pub use handler::CupratedRpcHandler;

binaries/cuprated/src/rpc/bin.rs

@@ -1,8 +1,10 @@
 //! RPC request handler functions (binary endpoints).
 
 use anyhow::{anyhow, Error};
+use bytes::Bytes;
 
 use cuprate_constants::rpc::{RESTRICTED_BLOCK_COUNT, RESTRICTED_TRANSACTIONS_COUNT};
+use cuprate_fixed_bytes::ByteArrayVec;
 use cuprate_rpc_interface::RpcHandler;
 use cuprate_rpc_types::{
     base::{AccessResponseBase, ResponseBase},
@@ -17,7 +19,11 @@ use cuprate_rpc_types::{
 };
 use cuprate_types::{rpc::PoolInfoExtent, BlockCompleteEntry};
 
-use crate::rpc::{helper, request::blockchain, CupratedRpcHandler};
+use crate::rpc::{
+    helper,
+    request::{blockchain, txpool},
+    shared, CupratedRpcHandler,
+};
 
 /// Map a [`BinRequest`] to the function that will lead to a [`BinResponse`].
 pub(super) async fn map_request(
@@ -122,18 +128,16 @@ async fn get_blocks(
 
 /// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L817-L857>
 async fn get_blocks_by_height(
-    state: CupratedRpcHandler,
+    mut state: CupratedRpcHandler,
     request: GetBlocksByHeightRequest,
 ) -> Result<GetBlocksByHeightResponse, Error> {
     if state.is_restricted() && request.heights.len() > RESTRICTED_BLOCK_COUNT {
         return Err(anyhow!("Too many blocks requested in restricted mode"));
     }
 
-    let blocks = request
+    let blocks =
-        .heights
+        blockchain::block_complete_entries_by_height(&mut state.blockchain_read, request.heights)
-        .into_iter()
+            .await?;
-        .map(|height| Ok(todo!()))
-        .collect::<Result<Vec<BlockCompleteEntry>, Error>>()?;
 
     Ok(GetBlocksByHeightResponse {
         base: helper::access_response_base(false),
@@ -157,13 +161,6 @@ async fn get_hashes(
         request.block_ids[len - 1]
     };
 
-    const GENESIS_BLOCK_HASH: [u8; 32] = [0; 32]; // TODO
-    if last != GENESIS_BLOCK_HASH {
-        return Err(anyhow!(
-            "genesis block mismatch, found: {last:?}, expected: {GENESIS_BLOCK_HASH:?}"
-        ));
-    }
-
     let mut bytes = request.block_ids;
     let hashes: Vec<[u8; 32]> = (&bytes).into();
 
@@ -187,12 +184,12 @@ async fn get_hashes(
 
 /// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L959-L977>
 async fn get_output_indexes(
-    state: CupratedRpcHandler,
+    mut state: CupratedRpcHandler,
     request: GetOutputIndexesRequest,
 ) -> Result<GetOutputIndexesResponse, Error> {
     Ok(GetOutputIndexesResponse {
         base: helper::access_response_base(false),
-        ..todo!()
+        o_indexes: blockchain::tx_output_indexes(&mut state.blockchain_read, request.txid).await?,
     })
 }
 
@@ -201,20 +198,19 @@ async fn get_outs(
     state: CupratedRpcHandler,
     request: GetOutsRequest,
 ) -> Result<GetOutsResponse, Error> {
-    Ok(GetOutsResponse {
+    shared::get_outs(state, request).await
-        base: helper::access_response_base(false),
-        ..todo!()
-    })
 }
 
 /// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L1689-L1711>
 async fn get_transaction_pool_hashes(
-    state: CupratedRpcHandler,
+    mut state: CupratedRpcHandler,
-    request: GetTransactionPoolHashesRequest,
+    _: GetTransactionPoolHashesRequest,
 ) -> Result<GetTransactionPoolHashesResponse, Error> {
     Ok(GetTransactionPoolHashesResponse {
         base: helper::access_response_base(false),
-        ..todo!()
+        tx_hashes: shared::get_transaction_pool_hashes(state)
+            .await
+            .map(ByteArrayVec::from)?,
     })
 }
 
@@ -223,8 +219,5 @@ async fn get_output_distribution(
     state: CupratedRpcHandler,
     request: GetOutputDistributionRequest,
 ) -> Result<GetOutputDistributionResponse, Error> {
-    Ok(GetOutputDistributionResponse {
+    shared::get_output_distribution(state, request).await
-        base: helper::access_response_base(false),
-        ..todo!()
-    })
 }

binaries/cuprated/src/rpc/json.rs

@@ -62,7 +62,7 @@ use crate::{
     rpc::{
         helper,
         request::{address_book, blockchain, blockchain_context, blockchain_manager, txpool},
-        CupratedRpcHandler,
+        shared, CupratedRpcHandler,
     },
     statics::START_INSTANT_UNIX,
 };
@@ -958,35 +958,10 @@ async fn get_transaction_pool_backlog(
 
 /// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L3352-L3398>
 async fn get_output_distribution(
-    mut state: CupratedRpcHandler,
+    state: CupratedRpcHandler,
     request: GetOutputDistributionRequest,
 ) -> Result<GetOutputDistributionResponse, Error> {
-    if state.is_restricted() && request.amounts != [1, 0] {
+    shared::get_output_distribution(state, request).await
-        return Err(anyhow!(
-            "Restricted RPC can only get output distribution for RCT outputs. Use your own node."
-        ));
-    }
-
-    // 0 is placeholder for the whole chain
-    let req_to_height = if request.to_height == 0 {
-        helper::top_height(&mut state).await?.0.saturating_sub(1)
-    } else {
-        request.to_height
-    };
-
-    let distributions = request.amounts.into_iter().map(|amount| {
-        fn get_output_distribution() -> Result<Distribution, Error> {
-            todo!("https://github.com/monero-project/monero/blob/893916ad091a92e765ce3241b94e706ad012b62a/src/rpc/rpc_handler.cpp#L29");
-            Err(anyhow!("Failed to get output distribution"))
-        }
-
-        get_output_distribution()
-    }).collect::<Result<Vec<Distribution>, _>>()?;
-
-    Ok(GetOutputDistributionResponse {
-        base: helper::access_response_base(false),
-        distributions,
-    })
 }
 
 /// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L1998-L2033>

binaries/cuprated/src/rpc/other.rs

@@ -37,7 +37,7 @@ use cuprate_rpc_types::{
     },
 };
 use cuprate_types::{
-    rpc::{KeyImageSpentStatus, OutKey, PoolInfo, PoolTxInfo, PublicNode},
+    rpc::{KeyImageSpentStatus, PoolInfo, PoolTxInfo, PublicNode},
     TxInPool, TxRelayChecks,
 };
 use monero_serai::transaction::{Input, Timelock, Transaction};
@@ -47,7 +47,7 @@ use crate::{
     rpc::{
         helper,
         request::{blockchain, blockchain_context, blockchain_manager, txpool},
-        CupratedRpcHandler,
+        shared, CupratedRpcHandler,
     },
     statics::START_INSTANT_UNIX,
 };
@@ -610,45 +610,21 @@ async fn get_net_stats(
 
 /// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L912-L957>
 async fn get_outs(
-    mut state: CupratedRpcHandler,
+    state: CupratedRpcHandler,
     request: GetOutsRequest,
 ) -> Result<GetOutsResponse, Error> {
-    if state.is_restricted() && request.outputs.len() > MAX_RESTRICTED_GLOBAL_FAKE_OUTS_COUNT {
+    let outs = shared::get_outs(
-        return Err(anyhow!("Too many outs requested"));
+        state,
-    }
+        cuprate_rpc_types::bin::GetOutsRequest {
-
+            outputs: request.outputs,
-    let outputs = {
+            get_txid: request.get_txid,
-        let mut outputs = HashMap::<u64, HashSet<u64>>::with_capacity(request.outputs.len());
+        },
-
+    )
-        for out in request.outputs {
+    .await?
-            outputs
+    .outs
-                .entry(out.amount)
+    .into_iter()
-                .and_modify(|set| {
+    .map(Into::into)
-                    set.insert(out.index);
+    .collect();
-                })
-                .or_insert_with(|| HashSet::from([out.index]));
-        }
-
-        outputs
-    };
-
-    let outs = blockchain::outputs(&mut state.blockchain_read, outputs)
-        .await?
-        .into_iter()
-        .flat_map(|(amount, index_map)| {
-            index_map.into_iter().map(|(index, out)| OutKey {
-                key: out.key.map_or(Hex([0; 32]), |e| Hex(e.compress().0)),
-                mask: Hex(out.commitment.compress().0),
-                unlocked: matches!(out.time_lock, Timelock::None),
-                height: usize_to_u64(out.height),
-                txid: if request.get_txid {
-                    hex::encode(out.txid)
-                } else {
-                    String::new()
-                },
-            })
-        })
-        .collect::<Vec<OutKey>>();
 
     Ok(GetOutsResponse {
         base: helper::response_base(false),
@@ -675,20 +651,13 @@ async fn get_transaction_pool_hashes(
     mut state: CupratedRpcHandler,
     _: GetTransactionPoolHashesRequest,
 ) -> Result<GetTransactionPoolHashesResponse, Error> {
-    let include_sensitive_txs = !state.is_restricted();
-
-    // FIXME: this request is a bit overkill, we only need the hashes.
-    // We could create a separate request for this.
-    let tx_hashes = txpool::pool(&mut state.txpool_read, include_sensitive_txs)
-        .await?
-        .0
-        .into_iter()
-        .map(|tx| tx.id_hash)
-        .collect();
-
     Ok(GetTransactionPoolHashesResponse {
         base: helper::response_base(false),
-        tx_hashes,
+        tx_hashes: shared::get_transaction_pool_hashes(state)
+            .await?
+            .into_iter()
+            .map(Hex)
+            .collect(),
     })
 }
 

binaries/cuprated/src/rpc/request/blockchain.rs

@@ -16,7 +16,7 @@ use cuprate_types::{
     rpc::{
         ChainInfo, CoinbaseTxSum, KeyImageSpentStatus, OutputHistogramEntry, OutputHistogramInput,
     },
-    Chain, ExtendedBlockHeader, OutputOnChain, TxInBlockchain,
+    BlockCompleteEntry, Chain, ExtendedBlockHeader, OutputOnChain, TxInBlockchain,
 };
 
 /// [`BlockchainReadRequest::Block`].
@@ -399,7 +399,7 @@ pub(crate) async fn transactions(
 pub(crate) async fn total_rct_outputs(
     blockchain_read: &mut BlockchainReadHandle,
 ) -> Result<u64, Error> {
-    let BlockchainResponse::TotalRctOutputs(total_rct_outputs) = blockchain_read
+    let BlockchainResponse::TotalRctOutputs(n) = blockchain_read
         .ready()
         .await?
         .call(BlockchainReadRequest::TotalRctOutputs)
@@ -408,5 +408,41 @@ pub(crate) async fn total_rct_outputs(
         unreachable!();
     };
 
-    Ok(total_rct_outputs)
+    Ok(n)
+}
+
+/// [`BlockchainReadRequest::BlockCompleteEntriesByHeight`].
+pub(crate) async fn block_complete_entries_by_height(
+    blockchain_read: &mut BlockchainReadHandle,
+    block_heights: Vec<u64>,
+) -> Result<Vec<BlockCompleteEntry>, Error> {
+    let BlockchainResponse::BlockCompleteEntriesByHeight(blocks) = blockchain_read
+        .ready()
+        .await?
+        .call(BlockchainReadRequest::BlockCompleteEntriesByHeight(
+            block_heights.into_iter().map(u64_to_usize).collect(),
+        ))
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(blocks)
+}
+
+/// [`BlockchainReadRequest::TxOutputIndexes`].
+pub(crate) async fn tx_output_indexes(
+    blockchain_read: &mut BlockchainReadHandle,
+    tx_hash: [u8; 32],
+) -> Result<Vec<u64>, Error> {
+    let BlockchainResponse::TxOutputIndexes(o_indexes) = blockchain_read
+        .ready()
+        .await?
+        .call(BlockchainReadRequest::TxOutputIndexes { tx_hash })
+        .await?
+    else {
+        unreachable!();
+    };
+
+    Ok(o_indexes)
 }

binaries/cuprated/src/rpc/shared.rs

@@ -0,0 +1,132 @@
+//! RPC handler functions that are shared between different endpoint/methods.
+
+use std::collections::{HashMap, HashSet};
+
+use anyhow::{anyhow, Error};
+use monero_serai::transaction::Timelock;
+
+use cuprate_constants::rpc::MAX_RESTRICTED_GLOBAL_FAKE_OUTS_COUNT;
+use cuprate_helper::cast::usize_to_u64;
+use cuprate_hex::Hex;
+use cuprate_rpc_interface::RpcHandler;
+use cuprate_rpc_types::{
+    bin::{
+        GetOutsRequest, GetOutsResponse, GetTransactionPoolHashesRequest,
+        GetTransactionPoolHashesResponse,
+    },
+    json::{GetOutputDistributionRequest, GetOutputDistributionResponse},
+    misc::{Distribution, OutKeyBin},
+};
+
+use crate::rpc::{
+    helper,
+    request::{blockchain, txpool},
+    CupratedRpcHandler,
+};
+
+/// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L912-L957>
+///
+/// Shared between:
+/// - Other JSON's `/get_outs`
+/// - Binary's `/get_outs.bin`
+pub(super) async fn get_outs(
+    mut state: CupratedRpcHandler,
+    request: GetOutsRequest,
+) -> Result<GetOutsResponse, Error> {
+    if state.is_restricted() && request.outputs.len() > MAX_RESTRICTED_GLOBAL_FAKE_OUTS_COUNT {
+        return Err(anyhow!("Too many outs requested"));
+    }
+
+    let outputs = {
+        let mut outputs = HashMap::<u64, HashSet<u64>>::with_capacity(request.outputs.len());
+
+        for out in request.outputs {
+            outputs
+                .entry(out.amount)
+                .and_modify(|set| {
+                    set.insert(out.index);
+                })
+                .or_insert_with(|| HashSet::from([out.index]));
+        }
+
+        outputs
+    };
+
+    let outs = blockchain::outputs(&mut state.blockchain_read, outputs)
+        .await?
+        .into_iter()
+        .flat_map(|(amount, index_map)| {
+            index_map.into_values().map(|out| OutKeyBin {
+                key: out.key.map_or([0; 32], |e| e.compress().0),
+                mask: out.commitment.compress().0,
+                unlocked: matches!(out.time_lock, Timelock::None),
+                height: usize_to_u64(out.height),
+                txid: if request.get_txid { out.txid } else { [0; 32] },
+            })
+        })
+        .collect::<Vec<OutKeyBin>>();
+
+    Ok(GetOutsResponse {
+        base: helper::access_response_base(false),
+        outs,
+    })
+}
+
+/// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L1713-L1739>
+///
+/// Shared between:
+/// - Other JSON's `/get_transaction_pool_hashes`
+/// - Binary's `/get_transaction_pool_hashes.bin`
+///
+/// Returns transaction hashes.
+pub(super) async fn get_transaction_pool_hashes(
+    mut state: CupratedRpcHandler,
+) -> Result<Vec<[u8; 32]>, Error> {
+    let include_sensitive_txs = !state.is_restricted();
+
+    // FIXME: this request is a bit overkill, we only need the hashes.
+    // We could create a separate request for this.
+    Ok(txpool::pool(&mut state.txpool_read, include_sensitive_txs)
+        .await?
+        .0
+        .into_iter()
+        .map(|tx| tx.id_hash.0)
+        .collect())
+}
+
+/// <https://github.com/monero-project/monero/blob/cc73fe71162d564ffda8e549b79a350bca53c454/src/rpc/core_rpc_server.cpp#L3352-L3398>
+///
+/// Shared between:
+/// - JSON-RPC's `get_output_distribution`
+/// - Binary's `/get_output_distribution.bin`
+pub(super) async fn get_output_distribution(
+    mut state: CupratedRpcHandler,
+    request: GetOutputDistributionRequest,
+) -> Result<GetOutputDistributionResponse, Error> {
+    if state.is_restricted() && request.amounts != [1, 0] {
+        return Err(anyhow!(
+            "Restricted RPC can only get output distribution for RCT outputs. Use your own node."
+        ));
+    }
+
+    // 0 is placeholder for the whole chain
+    let req_to_height = if request.to_height == 0 {
+        helper::top_height(&mut state).await?.0.saturating_sub(1)
+    } else {
+        request.to_height
+    };
+
+    let distributions = request.amounts.into_iter().map(|amount| {
+        fn get_output_distribution() -> Result<Distribution, Error> {
+            todo!("https://github.com/monero-project/monero/blob/893916ad091a92e765ce3241b94e706ad012b62a/src/rpc/rpc_handler.cpp#L29");
+            Err(anyhow!("Failed to get output distribution"))
+        }
+
+        get_output_distribution()
+    }).collect::<Result<Vec<Distribution>, _>>()?;
+
+    Ok(GetOutputDistributionResponse {
+        base: helper::access_response_base(false),
+        distributions,
+    })
+}

rpc/types/src/bin.rs

@@ -120,7 +120,6 @@ define_request_and_response! {
 
     Request {
         requested_info: u8 = default::<u8>(), "default",
-        // FIXME: This is a `std::list` in `monerod` because...?
         block_ids: ByteArrayVec<32> = default::<ByteArrayVec<32>>(), "default",
         start_height: u64,
         prune: bool,

rpc/types/src/from.rs

@@ -193,3 +193,15 @@ impl From<SpentKeyImageInfo> for crate::misc::SpentKeyImageInfo {
         }
     }
 }
+
+impl From<crate::misc::OutKeyBin> for crate::misc::OutKey {
+    fn from(x: crate::misc::OutKeyBin) -> Self {
+        Self {
+            key: Hex(x.key),
+            mask: Hex(x.mask),
+            unlocked: x.unlocked,
+            height: x.height,
+            txid: hex::encode(x.txid),
+        }
+    }
+}

rpc/types/src/misc/mod.rs

@@ -25,6 +25,6 @@ pub use requested_info::RequestedInfo;
 pub use status::Status;
 pub use tx_entry::{TxEntry, TxEntryType};
 pub use types::{
-    BlockHeader, ChainInfo, ConnectionInfo, GetBan, GetOutputsOut, HistogramEntry, OutKeyBin,
+    BlockHeader, ChainInfo, ConnectionInfo, GetBan, GetOutputsOut, HistogramEntry, OutKey,
-    SetBan, Span, SpentKeyImageInfo, SyncInfoPeer, TxInfo,
+    OutKeyBin, SetBan, Span, SpentKeyImageInfo, SyncInfoPeer, TxInfo,
 };

rpc/types/src/misc/types.rs

@@ -252,6 +252,23 @@ define_struct_and_impl_epee! {
     }
 }
 
+define_struct_and_impl_epee! {
+    #[doc = monero_definition_link!(
+        "cc73fe71162d564ffda8e549b79a350bca53c454",
+        "rpc/core_rpc_server_commands_defs.h",
+        582..=597
+    )]
+    /// Used in [`crate::other::GetOutsRequest`].
+    OutKey {
+        key: Hex<32>,
+        mask: Hex<32>,
+        unlocked: bool,
+        height: u64,
+        /// Optionally empty with `/get_outs`'s `"get_txid": false`.
+        txid: String,
+    }
+}
+
 define_struct_and_impl_epee! {
     #[doc = monero_definition_link!(
         "cc73fe71162d564ffda8e549b79a350bca53c454",

rpc/types/src/other.rs

@@ -7,12 +7,12 @@
 use serde::{Deserialize, Serialize};
 
 use cuprate_hex::Hex;
-use cuprate_types::rpc::{OutKey, Peer, PublicNode, TxpoolStats};
+use cuprate_types::rpc::{Peer, PublicNode, TxpoolStats};
 
 use crate::{
     base::{AccessResponseBase, ResponseBase},
     macros::define_request_and_response,
-    misc::{GetOutputsOut, SpentKeyImageInfo, Status, TxEntry, TxInfo},
+    misc::{GetOutputsOut, OutKey, SpentKeyImageInfo, Status, TxEntry, TxInfo},
     RpcCallValue,
 };
 
@@ -1206,9 +1206,8 @@ mod test {
                         mask: Hex(hex!(
                             "1738eb7a677c6149228a2beaa21bea9e3370802d72a3eec790119580e02bd522"
                         )),
-                        txid: Hex(hex!(
+                        txid: "9d651903b80fb70b9935b72081cd967f543662149aed3839222511acd9100601"
-                            "9d651903b80fb70b9935b72081cd967f543662149aed3839222511acd9100601"
+                            .into(),
-                        )),
                         unlocked: true,
                     },
                     OutKey {
@@ -1219,9 +1218,8 @@ mod test {
                         mask: Hex(hex!(
                             "1738eb7a677c6149228a2beaa21bea9e3370802d72a3eec790119580e02bd522"
                         )),
-                        txid: Hex(hex!(
+                        txid: "230bff732dc5f225df14fff82aadd1bf11b3fb7ad3a03413c396a617e843f7d0"
-                            "230bff732dc5f225df14fff82aadd1bf11b3fb7ad3a03413c396a617e843f7d0"
+                            .into(),
-                        )),
                         unlocked: true,
                     },
                 ],

storage/blockchain/src/ops/block.rs

@@ -254,7 +254,7 @@ pub fn get_block_blob_with_tx_indexes(
     Ok((block, miner_tx_idx, numb_txs))
 }
 
-//---------------------------------------------------------------------------------------------------- `get_block_extended_header_*`
+//---------------------------------------------------------------------------------------------------- `get_block_complete_entry_*`
 /// Retrieve a [`BlockCompleteEntry`] from the database.
 ///
 #[doc = doc_error!()]
@@ -263,8 +263,18 @@ pub fn get_block_complete_entry(
     tables: &impl TablesIter,
 ) -> Result<BlockCompleteEntry, RuntimeError> {
     let block_height = tables.block_heights().get(block_hash)?;
+    get_block_complete_entry_from_height(&block_height, tables)
+}
+
+/// Retrieve a [`BlockCompleteEntry`] from the database.
+///
+#[doc = doc_error!()]
+pub fn get_block_complete_entry_from_height(
+    block_height: &BlockHeight,
+    tables: &impl TablesIter,
+) -> Result<BlockCompleteEntry, RuntimeError> {
     let (block_blob, miner_tx_idx, numb_non_miner_txs) =
-        get_block_blob_with_tx_indexes(&block_height, tables)?;
+        get_block_blob_with_tx_indexes(block_height, tables)?;
 
     let first_tx_idx = miner_tx_idx + 1;
 

storage/blockchain/src/service/read.rs

@@ -41,7 +41,8 @@ use crate::{
         },
         block::{
             block_exists, get_block_blob_with_tx_indexes, get_block_complete_entry,
-            get_block_extended_header_from_height, get_block_height, get_block_info,
+            get_block_complete_entry_from_height, get_block_extended_header_from_height,
+            get_block_height, get_block_info,
         },
         blockchain::{cumulative_generated_coins, find_split_point, top_block_height},
         key_image::key_image_exists,
@@ -53,6 +54,7 @@ use crate::{
     },
     tables::{
         AltBlockHeights, BlockHeights, BlockInfos, OpenTables, RctOutputs, Tables, TablesIter,
+        TxIds, TxOutputs,
     },
     types::{
         AltBlockHeight, Amount, AmountIndex, BlockHash, BlockHeight, KeyImage, PreRctOutputId,
@@ -108,6 +110,7 @@ fn map_request(
 
     match request {
         R::BlockCompleteEntries(block_hashes) => block_complete_entries(env, block_hashes),
+        R::BlockCompleteEntriesByHeight(heights) => block_complete_entries_by_height(env, heights),
         R::BlockExtendedHeader(block) => block_extended_header(env, block),
         R::BlockHash(block, chain) => block_hash(env, block, chain),
         R::FindBlock(block_hash) => find_block(env, block_hash),
@@ -138,6 +141,7 @@ fn map_request(
         R::AltChainCount => alt_chain_count(env),
         R::Transactions { tx_hashes } => transactions(env, tx_hashes),
         R::TotalRctOutputs => total_rct_outputs(env),
+        R::TxOutputIndexes { tx_hash } => tx_output_indexes(env, &tx_hash),
     }
 
     /* SOMEDAY: post-request handling, run some code for each request? */
@@ -245,6 +249,31 @@ fn block_complete_entries(env: &ConcreteEnv, block_hashes: Vec<BlockHash>) -> Re
     })
 }
 
+/// [`BlockchainReadRequest::BlockCompleteEntriesByHeight`].
+fn block_complete_entries_by_height(
+    env: &ConcreteEnv,
+    block_heights: Vec<BlockHeight>,
+) -> ResponseResult {
+    // Prepare tx/tables in `ThreadLocal`.
+    let env_inner = env.env_inner();
+    let tx_ro = thread_local(env);
+    let tables = thread_local(env);
+
+    let blocks = block_heights
+        .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_block_complete_entry_from_height(&height, tables)
+        })
+        .collect::<DbResult<_>>()?;
+
+    let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
+    let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
+
+    Ok(BlockchainResponse::BlockCompleteEntriesByHeight(blocks))
+}
+
 /// [`BlockchainReadRequest::BlockExtendedHeader`].
 #[inline]
 fn block_extended_header(env: &ConcreteEnv, block_height: BlockHeight) -> ResponseResult {
@@ -792,3 +821,14 @@ fn total_rct_outputs(env: &ConcreteEnv) -> ResponseResult {
 
     Ok(BlockchainResponse::TotalRctOutputs(len))
 }
+
+/// [`BlockchainReadRequest::TxOutputIndexes`]
+fn tx_output_indexes(env: &ConcreteEnv, tx_hash: &[u8; 32]) -> ResponseResult {
+    // Single-threaded, no `ThreadLocal` required.
+    let env_inner = env.env_inner();
+    let tx_ro = env_inner.tx_ro()?;
+    let tx_id = env_inner.open_db_ro::<TxIds>(&tx_ro)?.get(tx_hash)?;
+    let o_indexes = env_inner.open_db_ro::<TxOutputs>(&tx_ro)?.get(&tx_id)?;
+
+    Ok(BlockchainResponse::TxOutputIndexes(o_indexes.0))
+}

types/types/src/blockchain.rs

@@ -32,6 +32,11 @@ pub enum BlockchainReadRequest {
     /// The input is the block hashes.
     BlockCompleteEntries(Vec<[u8; 32]>),
 
+    /// Request [`BlockCompleteEntry`]s.
+    ///
+    /// The input is the block heights.
+    BlockCompleteEntriesByHeight(Vec<usize>),
+
     /// Request a block's extended header.
     ///
     /// The input is the block's height.
@@ -166,6 +171,9 @@ pub enum BlockchainReadRequest {
 
     /// TODO
     TotalRctOutputs,
+
+    /// TODO
+    TxOutputIndexes { tx_hash: [u8; 32] },
 }
 
 //---------------------------------------------------------------------------------------------------- WriteRequest
@@ -223,6 +231,9 @@ pub enum BlockchainResponse {
         blockchain_height: usize,
     },
 
+    /// Response to [`BlockchainReadRequest::BlockCompleteEntriesByHeight`].
+    BlockCompleteEntriesByHeight(Vec<BlockCompleteEntry>),
+
     /// Response to [`BlockchainReadRequest::BlockExtendedHeader`].
     ///
     /// Inner value is the extended headed of the requested block.
@@ -364,6 +375,9 @@ pub enum BlockchainResponse {
     /// Response to [`BlockchainReadRequest::TotalRctOutputs`].
     TotalRctOutputs(u64),
 
+    /// Response to [`BlockchainReadRequest::TxOutputIndexes`].
+    TxOutputIndexes(Vec<u64>),
+
     //------------------------------------------------------ Writes
     /// A generic Ok response to indicate a request was successfully handled.
     ///

types/types/src/rpc/mod.rs

@@ -16,7 +16,7 @@ pub use pool_info_extent::PoolInfoExtent;
 pub use types::{
     AddAuxPow, AuxPow, BlockHeader, BlockOutputIndices, ChainInfo, CoinbaseTxSum, ConnectionInfo,
     FeeEstimate, GetBan, GetMinerDataTxBacklogEntry, GetOutputsOut, HardForkEntry, HardForkInfo,
-    HistogramEntry, MinerData, MinerDataTxBacklogEntry, OutKey, OutKeyBin, OutputDistributionData,
+    HistogramEntry, MinerData, MinerDataTxBacklogEntry, OutputDistributionData,
     OutputHistogramEntry, OutputHistogramInput, Peer, PoolInfoFull, PoolInfoIncremental,
     PoolTxInfo, PublicNode, SetBan, Span, SpentKeyImageInfo, SyncInfoPeer, TxBacklogEntry, TxInfo,
     TxOutputIndices, TxpoolHisto, TxpoolStats,

types/types/src/rpc/types.rs

@@ -308,19 +308,6 @@ define_struct_and_impl_epee! {
         index: u64,
     }
 
-    #[doc = monero_definition_link!(
-        "cc73fe71162d564ffda8e549b79a350bca53c454",
-        "rpc/core_rpc_server_commands_defs.h",
-        538..=553
-    )]
-    OutKeyBin {
-        key: [u8; 32],
-        mask: [u8; 32],
-        unlocked: bool,
-        height: u64,
-        txid: [u8; 32],
-    }
-
     #[doc = monero_definition_link!(
         "cc73fe71162d564ffda8e549b79a350bca53c454",
         "rpc/core_rpc_server_commands_defs.h",
@@ -419,20 +406,6 @@ define_struct_and_impl_epee! {
         txs_total: u32,
     }
 
-    #[doc = monero_definition_link!(
-        "cc73fe71162d564ffda8e549b79a350bca53c454",
-        "rpc/core_rpc_server_commands_defs.h",
-        582..=597
-    )]
-    OutKey {
-        key: Hex<32>,
-        mask: Hex<32>,
-        unlocked: bool,
-        height: u64,
-        // Optionally empty with `/get_outs`'s `"get_txid": false`.
-        txid: String,
-    }
-
     #[doc = monero_definition_link!(
         "893916ad091a92e765ce3241b94e706ad012b62a",
         "blockchain_db/lmdb/db_lmdb.cpp",