use indexmap to request outputs

binaries/cuprated/src/blockchain/manager/handler.rs

@@ -166,9 +166,12 @@ impl super::BlockchainManager {
     /// This function will panic if any internal service returns an unexpected error that we cannot
     /// recover from or if the incoming batch contains no blocks.
     async fn handle_incoming_block_batch_main_chain(&mut self, batch: BlockBatch) {
-        let Ok((prepped_blocks, mut output_cache)) =
-            batch_prepare_main_chain_blocks(batch.blocks, &mut self.blockchain_context_service, self.blockchain_read_handle.clone())
-                .await
+        let Ok((prepped_blocks, mut output_cache)) = batch_prepare_main_chain_blocks(
+            batch.blocks,
+            &mut self.blockchain_context_service,
+            self.blockchain_read_handle.clone(),
+        )
+        .await
         else {
             batch.peer_handle.ban_peer(LONG_BAN);
             self.stop_current_block_downloader.notify_one();
@@ -181,7 +184,7 @@ impl super::BlockchainManager {
                 txs,
                 &mut self.blockchain_context_service,
                 self.blockchain_read_handle.clone(),
-                Some(&mut output_cache)
+                Some(&mut output_cache),
             )
             .await
             else {
@@ -405,7 +408,7 @@ impl super::BlockchainManager {
                 prepped_txs,
                 &mut self.blockchain_context_service,
                 self.blockchain_read_handle.clone(),
-                None
+                None,
             )
             .await?;
 

binaries/cuprated/src/blockchain/syncer.rs

@@ -6,6 +6,7 @@ use tokio::{
     sync::{mpsc, Notify},
     time::interval,
 };
+use tokio::sync::oneshot;
 use tower::{Service, ServiceExt};
 use tracing::instrument;
 

binaries/cuprated/src/main.rs

@@ -23,14 +23,14 @@ use tower::{Service, ServiceExt};
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::{layer::SubscriberExt, reload::Handle, util::SubscriberInitExt, Registry};
 
+use crate::{
+    config::Config, constants::PANIC_CRITICAL_SERVICE_ERROR, logging::CupratedTracingFilter,
+};
 use cuprate_consensus_context::{
     BlockChainContextRequest, BlockChainContextResponse, BlockchainContextService,
 };
 use cuprate_helper::time::secs_to_hms;
 use cuprate_types::blockchain::BlockchainWriteRequest;
-use crate::{
-    config::Config, constants::PANIC_CRITICAL_SERVICE_ERROR, logging::CupratedTracingFilter,
-};
 
 mod blockchain;
 mod commands;
@@ -77,7 +77,6 @@ fn main() {
     // Initialize async tasks.
 
     rt.block_on(async move {
-
         // Check add the genesis block to the blockchain.
         blockchain::check_add_genesis(
             &mut blockchain_read_handle,

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

@@ -190,7 +190,7 @@ pub(crate) async fn outputs(
     let BlockchainResponse::Outputs(outputs) = blockchain_read
         .ready()
         .await?
-        .call(BlockchainReadRequest::Outputs(outputs))
+        .call(BlockchainReadRequest::Outputs(todo!()))
         .await?
     else {
         unreachable!();

binaries/cuprated/src/txpool/incoming_tx.rs

@@ -172,7 +172,7 @@ async fn handle_incoming_txs(
             context.current_adjusted_timestamp_for_time_lock(),
             context.current_hf,
             blockchain_read_handle,
-            None
+            None,
         )
         .verify()
         .await

consensus/Cargo.toml

@@ -23,6 +23,7 @@ monero-serai = { workspace = true, features = ["std"] }
 rayon = { workspace = true }
 thread_local = { workspace = true }
 
+indexmap = { workspace = true, features = ["std"] }
 hex = { workspace = true }
 rand = { workspace = true }
 

consensus/rules/Cargo.toml

@@ -21,6 +21,7 @@ curve25519-dalek = { workspace = true, features = ["alloc", "zeroize", "precompu
 
 rand = { workspace = true, features = ["std", "std_rng"] }
 
+indexmap = { workspace = true, features = ["std"] }
 hex = { workspace = true, features = ["std"] }
 hex-literal = { workspace = true }
 crypto-bigint = { workspace = true }

consensus/rules/src/transactions/contextual_data.rs

@@ -1,9 +1,9 @@
 use std::{
     cmp::{max, min},
-    collections::{HashMap, HashSet},
 };
 
 use curve25519_dalek::EdwardsPoint;
+use indexmap::{IndexMap, IndexSet};
 use monero_serai::transaction::{Input, Timelock};
 
 use crate::{transactions::TransactionError, HardFork};
@@ -33,7 +33,7 @@ pub fn get_absolute_offsets(relative_offsets: &[u64]) -> Result<Vec<u64>, Transa
 ///
 pub fn insert_ring_member_ids(
     inputs: &[Input],
-    output_ids: &mut HashMap<u64, HashSet<u64>>,
+    output_ids: &mut IndexMap<u64, IndexSet<u64>>,
 ) -> Result<(), TransactionError> {
     if inputs.is_empty() {
         return Err(TransactionError::NoInputs);

consensus/src/block.rs

@@ -37,7 +37,6 @@ mod free;
 
 pub use alt_block::sanity_check_alt_block;
 pub use batch_prepare::{batch_prepare_main_chain_blocks, BatchPrepareCache};
-use cuprate_types::output_cache::OutputCache;
 use free::pull_ordered_transactions;
 
 /// A pre-prepared block with all data needed to verify it, except the block's proof of work.
@@ -285,7 +284,7 @@ where
                 context.current_adjusted_timestamp_for_time_lock(),
                 context.current_hf,
                 database,
-                batch_prep_cache.as_ref().map(|o| &**o)
+                batch_prep_cache.as_ref().map(|o| &**o),
             )
             .verify()
             .await?;

consensus/src/block/batch_prepare.rs

@@ -16,28 +16,34 @@ use cuprate_helper::asynch::rayon_spawn_async;
 use cuprate_types::output_cache::OutputCache;
 use cuprate_types::TransactionVerificationData;
 
+use crate::__private::Database;
+use crate::transactions::check_kis_unique;
+use crate::transactions::contextual_data::get_output_cache;
 use crate::{
     batch_verifier::MultiThreadedBatchVerifier,
     block::{free::order_transactions, PreparedBlock, PreparedBlockExPow},
     transactions::start_tx_verification,
     BlockChainContextRequest, BlockChainContextResponse, ExtendedConsensusError,
 };
-use crate::__private::Database;
-use crate::transactions::check_kis_unique;
-use crate::transactions::contextual_data::get_output_cache;
 
 pub struct BatchPrepareCache {
     pub(crate) output_cache: OutputCache,
-    pub(crate) key_images_spent_checked: bool
+    pub(crate) key_images_spent_checked: bool,
 }
 
 /// Batch prepares a list of blocks for verification.
 #[instrument(level = "debug", name = "batch_prep_blocks", skip_all, fields(amt = blocks.len()))]
 pub async fn batch_prepare_main_chain_blocks<D: Database>(
     blocks: Vec<(Block, Vec<Transaction>)>,
     context_svc: &mut BlockchainContextService,
-    mut database: D
-) -> Result<(Vec<(PreparedBlock, Vec<TransactionVerificationData>)>, BatchPrepareCache), ExtendedConsensusError> {
+    mut database: D,
+) -> Result<
+    (
+        Vec<(PreparedBlock, Vec<TransactionVerificationData>)>,
+        BatchPrepareCache,
+    ),
+    ExtendedConsensusError,
+> {
     let (blocks, txs): (Vec<_>, Vec<_>) = blocks.into_iter().unzip();
 
     tracing::debug!("Calculating block hashes.");
@@ -201,10 +207,14 @@ pub async fn batch_prepare_main_chain_blocks<D: Database>(
 
     check_kis_unique(blocks.iter().flat_map(|(_, txs)| txs.iter()), &mut database).await?;
 
-    let output_cache = get_output_cache(blocks.iter().flat_map(|(_, txs)| txs.iter()), database).await?;
+    let output_cache =
+        get_output_cache(blocks.iter().flat_map(|(_, txs)| txs.iter()), database).await?;
 
-    Ok((blocks, BatchPrepareCache {
-        output_cache,
-        key_images_spent_checked: true
-    }))
+    Ok((
+        blocks,
+        BatchPrepareCache {
+            output_cache,
+            key_images_spent_checked: true,
+        },
+    ))
 }

consensus/src/lib.rs

@@ -75,7 +75,7 @@ pub mod __private {
         BlockchainReadRequest,
         Response = BlockchainResponse,
         Error = tower::BoxError,
-         Future: Send + 'static,
+        Future: Send + 'static,
     >
     {
     }

consensus/src/transactions.rs

@@ -31,6 +31,11 @@ use monero_serai::transaction::{Input, Timelock, Transaction};
 use rayon::prelude::*;
 use tower::ServiceExt;
 
+use crate::{
+    batch_verifier::MultiThreadedBatchVerifier,
+    transactions::contextual_data::{batch_get_decoy_info, batch_get_ring_member_info},
+    Database, ExtendedConsensusError,
+};
 use cuprate_consensus_rules::{
     transactions::{
         check_decoy_info, check_transaction_contextual, check_transaction_semantic,
@@ -39,22 +44,17 @@ use cuprate_consensus_rules::{
     ConsensusError, HardFork,
 };
 use cuprate_helper::asynch::rayon_spawn_async;
+use cuprate_types::output_cache::OutputCache;
 use cuprate_types::{
     blockchain::{BlockchainReadRequest, BlockchainResponse},
     CachedVerificationState, TransactionVerificationData, TxVersion,
 };
-use cuprate_types::output_cache::OutputCache;
-use crate::{
-    batch_verifier::MultiThreadedBatchVerifier,
-    transactions::contextual_data::{batch_get_decoy_info, batch_get_ring_member_info},
-    Database, ExtendedConsensusError,
-};
 
 pub mod contextual_data;
 mod free;
 
-pub use free::new_tx_verification_data;
 use crate::block::BatchPrepareCache;
+pub use free::new_tx_verification_data;
 
 /// An enum representing the type of validation that needs to be completed for this transaction.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -156,7 +156,7 @@ impl VerificationWanted {
         time_for_time_lock: u64,
         hf: HardFork,
         database: D,
-        batch_prep_cache: Option<&BatchPrepareCache>
+        batch_prep_cache: Option<&BatchPrepareCache>,
     ) -> FullVerification<D> {
         FullVerification {
             prepped_txs: self.prepped_txs,
@@ -165,7 +165,7 @@ impl VerificationWanted {
             time_for_time_lock,
             hf,
             database,
-            batch_prep_cache
+            batch_prep_cache,
         }
     }
 }
@@ -219,15 +219,18 @@ pub struct FullVerification<'a, D> {
     time_for_time_lock: u64,
     hf: HardFork,
     database: D,
-    batch_prep_cache: Option<&'a BatchPrepareCache>
+    batch_prep_cache: Option<&'a BatchPrepareCache>,
 }
 
 impl<D: Database + Clone> FullVerification<'_, D> {
     /// Fully verify each transaction.
     pub async fn verify(
         mut self,
     ) -> Result<Vec<TransactionVerificationData>, ExtendedConsensusError> {
-        if self.batch_prep_cache.is_none_or(|c| !c.key_images_spent_checked) {
+        if self
+            .batch_prep_cache
+            .is_none_or(|c| !c.key_images_spent_checked)
+        {
             check_kis_unique(self.prepped_txs.iter(), &mut self.database).await?;
         }
 
@@ -269,7 +272,7 @@ impl<D: Database + Clone> FullVerification<'_, D> {
             self.time_for_time_lock,
             self.hf,
             self.database,
-            self.batch_prep_cache.map(|c| &c.output_cache)
+            self.batch_prep_cache.map(|c| &c.output_cache),
         )
         .await
     }
@@ -440,7 +443,7 @@ async fn verify_transactions_decoy_info<D: Database>(
     txs: impl Iterator<Item = &TransactionVerificationData> + Clone,
     hf: HardFork,
     database: D,
-    output_cache: Option<&OutputCache>
+    output_cache: Option<&OutputCache>,
 ) -> Result<(), ExtendedConsensusError> {
     // Decoy info is not validated for V1 txs.
     if hf == HardFork::V1 {
@@ -467,7 +470,7 @@ async fn verify_transactions<D>(
     current_time_lock_timestamp: u64,
     hf: HardFork,
     database: D,
-    output_cache: Option<&OutputCache>
+    output_cache: Option<&OutputCache>,
 ) -> Result<Vec<TransactionVerificationData>, ExtendedConsensusError>
 where
     D: Database,
@@ -488,7 +491,7 @@ where
             .map(|(tx, _)| tx),
         hf,
         database,
-        output_cache
+        output_cache,
     )
     .await?;