cuprated: Add fast sync (#389)

* add specific method for context

* add new statemachine for tx verification

* fix consensus crates build

* working builds

* fix CI

* add docs

* fix CI

* fix docs

* fix clippy

* cleanup

* add docs to `blockchain_context`

* fix doc tests

* add output cache

* new monero-serai

* todo

* todo

* Revert "new monero-serai"

This reverts commit fe3f6ac.

* use indexmap to request outputs

* clean up

* fix typos

* fix CI

* fix cargo hack

* fix reorgs

* check if a block is already present before adding it to the alt block cache

* fmt

* update to new monero oxide API

* fmt & fix cache

* update config values

* fix tests

* add fast sync

* fix start_height check

* disable kill switch for now

* add fast sync config options

* add docs

* wait for all blocks to download before starting the syncer again.

* fix permit

* typo

* fix import order

* fmt

* add docs + order imports

* fix clippy

* review fixes

* rename top -> stop

Author: Boog900

Cargo.lock

@@ -20,11 +20,13 @@ use cuprate_types::{
 use crate::constants::PANIC_CRITICAL_SERVICE_ERROR;
 
 mod chain_service;
+mod fast_sync;
 pub mod interface;
 mod manager;
 mod syncer;
 mod types;
 
+pub use fast_sync::set_fast_sync_hashes;
 pub use manager::init_blockchain_manager;
 pub use types::ConsensusBlockchainReadHandle;
 

binaries/cuprated/src/blockchain.rs

@@ -4,7 +4,9 @@ use futures::{future::BoxFuture, FutureExt, TryFutureExt};
 use tower::Service;
 
 use cuprate_blockchain::service::BlockchainReadHandle;
+use cuprate_fast_sync::validate_entries;
 use cuprate_p2p::block_downloader::{ChainSvcRequest, ChainSvcResponse};
+use cuprate_p2p_core::NetworkZone;
 use cuprate_types::blockchain::{BlockchainReadRequest, BlockchainResponse};
 
 /// That service that allows retrieving the chain state to give to the P2P crates, so we can figure out
@@ -14,16 +16,16 @@ use cuprate_types::blockchain::{BlockchainReadRequest, BlockchainResponse};
 #[derive(Clone)]
 pub struct ChainService(pub BlockchainReadHandle);
 
-impl Service<ChainSvcRequest> for ChainService {
-    type Response = ChainSvcResponse;
+impl<N: NetworkZone> Service<ChainSvcRequest<N>> for ChainService {
+    type Response = ChainSvcResponse<N>;
     type Error = tower::BoxError;
     type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.0.poll_ready(cx).map_err(Into::into)
     }
 
-    fn call(&mut self, req: ChainSvcRequest) -> Self::Future {
+    fn call(&mut self, req: ChainSvcRequest<N>) -> Self::Future {
         let map_res = |res: BlockchainResponse| match res {
             BlockchainResponse::CompactChainHistory {
                 block_ids,
@@ -67,6 +69,18 @@ impl Service<ChainSvcRequest> for ChainService {
                 })
                 .map_err(Into::into)
                 .boxed(),
+            ChainSvcRequest::ValidateEntries(entries, start_height) => {
+                let mut blockchain_read_handle = self.0.clone();
+
+                async move {
+                    let (valid, unknown) =
+                        validate_entries(entries, start_height, &mut blockchain_read_handle)
+                            .await?;
+
+                    Ok(ChainSvcResponse::ValidateEntries { valid, unknown })
+                }
+                .boxed()
+            }
         }
     }
 }

binaries/cuprated/src/blockchain/chain_service.rs

@@ -0,0 +1,24 @@
+use std::slice;
+
+use cuprate_helper::network::Network;
+
+/// The hashes of the compiled in fast sync file.
+static FAST_SYNC_HASHES: &[[u8; 32]] = {
+    let bytes = include_bytes!("./fast_sync/fast_sync_hashes.bin");
+
+    if bytes.len() % 32 == 0 {
+        // SAFETY: The file byte length must be perfectly divisible by 32, checked above.
+        unsafe { slice::from_raw_parts(bytes.as_ptr().cast::<[u8; 32]>(), bytes.len() / 32) }
+    } else {
+        panic!();
+    }
+};
+
+/// Set the fast-sync hashes according to the provided values.
+pub fn set_fast_sync_hashes(fast_sync: bool, network: Network) {
+    cuprate_fast_sync::set_fast_sync_hashes(if fast_sync && network == Network::Mainnet {
+        FAST_SYNC_HASHES
+    } else {
+        &[]
+    });
+}

binaries/cuprated/src/blockchain/fast_sync.rs

@@ -2,7 +2,7 @@ use std::{collections::HashMap, sync::Arc};
 
 use futures::StreamExt;
 use monero_serai::block::Block;
-use tokio::sync::{mpsc, oneshot, Notify};
+use tokio::sync::{mpsc, oneshot, Notify, OwnedSemaphorePermit};
 use tower::{BoxError, Service, ServiceExt};
 use tracing::error;
 
@@ -106,15 +106,17 @@ impl BlockchainManager {
     /// The [`BlockchainManager`] task.
     pub async fn run(
         mut self,
-        mut block_batch_rx: mpsc::Receiver<BlockBatch>,
+        mut block_batch_rx: mpsc::Receiver<(BlockBatch, Arc<OwnedSemaphorePermit>)>,
         mut command_rx: mpsc::Receiver<BlockchainManagerCommand>,
     ) {
         loop {
             tokio::select! {
-                Some(batch) = block_batch_rx.recv() => {
+                Some((batch, permit)) = block_batch_rx.recv() => {
                     self.handle_incoming_block_batch(
                         batch,
                     ).await;
+
+                    drop(permit);
                 }
                 Some(incoming_command) = command_rx.recv() => {
                     self.handle_command(incoming_command).await;

binaries/cuprated/src/blockchain/fast_sync/fast_sync_hashes.bin

@@ -1,15 +1,15 @@
 //! The blockchain manager handler functions.
+use std::{collections::HashMap, sync::Arc};
+
 use bytes::Bytes;
 use futures::{TryFutureExt, TryStreamExt};
 use monero_serai::{
     block::Block,
     transaction::{Input, Transaction},
 };
 use rayon::prelude::*;
-use std::ops::ControlFlow;
-use std::{collections::HashMap, sync::Arc};
 use tower::{Service, ServiceExt};
-use tracing::{info, instrument};
+use tracing::{info, instrument, Span};
 
 use cuprate_blockchain::service::{BlockchainReadHandle, BlockchainWriteHandle};
 use cuprate_consensus::{
@@ -21,12 +21,13 @@ use cuprate_consensus::{
     BlockChainContextRequest, BlockChainContextResponse, ExtendedConsensusError,
 };
 use cuprate_consensus_context::NewBlockData;
+use cuprate_fast_sync::{block_to_verified_block_information, fast_sync_stop_height};
 use cuprate_helper::cast::usize_to_u64;
 use cuprate_p2p::{block_downloader::BlockBatch, constants::LONG_BAN, BroadcastRequest};
 use cuprate_txpool::service::interface::TxpoolWriteRequest;
 use cuprate_types::{
     blockchain::{BlockchainReadRequest, BlockchainResponse, BlockchainWriteRequest},
-    AltBlockInformation, HardFork, TransactionVerificationData, VerifiedBlockInformation,
+    AltBlockInformation, Chain, HardFork, TransactionVerificationData, VerifiedBlockInformation,
 };
 
 use crate::{
@@ -166,6 +167,11 @@ 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) {
+        if batch.blocks.last().unwrap().0.number().unwrap() < fast_sync_stop_height() {
+            self.handle_incoming_block_batch_fast_sync(batch).await;
+            return;
+        }
+
         let Ok((prepped_blocks, mut output_cache)) = batch_prepare_main_chain_blocks(
             batch.blocks,
             &mut self.blockchain_context_service,
@@ -195,7 +201,32 @@ impl super::BlockchainManager {
 
             self.add_valid_block_to_main_chain(verified_block).await;
         }
-        info!("Successfully added block batch");
+        info!(fast_sync = false, "Successfully added block batch");
+    }
+
+    /// Handles an incoming block batch while we are under the fast sync height.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if any internal service returns an unexpected error that we cannot
+    /// recover from.
+    async fn handle_incoming_block_batch_fast_sync(&mut self, batch: BlockBatch) {
+        let mut valid_blocks = Vec::with_capacity(batch.blocks.len());
+        for (block, txs) in batch.blocks {
+            let block = block_to_verified_block_information(
+                block,
+                txs,
+                self.blockchain_context_service.blockchain_context(),
+            );
+            self.add_valid_block_to_blockchain_cache(&block).await;
+
+            valid_blocks.push(block);
+        }
+
+        self.batch_add_valid_block_to_blockchain_database(valid_blocks)
+            .await;
+
+        info!(fast_sync = true, "Successfully added block batch");
     }
 
     /// Handles an incoming [`BlockBatch`] that does not follow the main-chain.
@@ -212,7 +243,6 @@ impl super::BlockchainManager {
     /// recover from.
     async fn handle_incoming_block_batch_alt_chain(&mut self, mut batch: BlockBatch) {
         // TODO: this needs testing (this whole section does but alt-blocks specifically).
-
         let mut blocks = batch.blocks.into_iter();
 
         while let Some((block, txs)) = blocks.next() {
@@ -248,6 +278,8 @@ impl super::BlockchainManager {
                 Ok(AddAltBlock::Cached) => (),
             }
         }
+
+        info!(alt_chain = true, "Successfully added block batch");
     }
 
     /// Handles an incoming alt [`Block`].
@@ -284,9 +316,10 @@ impl super::BlockchainManager {
             unreachable!();
         };
 
-        if chain.is_some() {
-            // The block could also be in the main-chain here under some circumstances.
-            return Ok(AddAltBlock::Cached);
+        match chain {
+            Some((Chain::Alt(_), _)) => return Ok(AddAltBlock::Cached),
+            Some((Chain::Main, _)) => anyhow::bail!("Alt block already in main chain"),
+            None => (),
         }
 
         let alt_block_info =
@@ -458,6 +491,36 @@ impl super::BlockchainManager {
             })
             .collect::<Vec<[u8; 32]>>();
 
+        self.add_valid_block_to_blockchain_cache(&verified_block)
+            .await;
+
+        self.blockchain_write_handle
+            .ready()
+            .await
+            .expect(PANIC_CRITICAL_SERVICE_ERROR)
+            .call(BlockchainWriteRequest::WriteBlock(verified_block))
+            .await
+            .expect(PANIC_CRITICAL_SERVICE_ERROR);
+
+        self.txpool_write_handle
+            .ready()
+            .await
+            .expect(PANIC_CRITICAL_SERVICE_ERROR)
+            .call(TxpoolWriteRequest::NewBlock { spent_key_images })
+            .await
+            .expect(PANIC_CRITICAL_SERVICE_ERROR);
+    }
+
+    /// Adds a [`VerifiedBlockInformation`] to the blockchain context cache.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if any internal service returns an unexpected error that we cannot
+    /// recover from.
+    async fn add_valid_block_to_blockchain_cache(
+        &mut self,
+        verified_block: &VerifiedBlockInformation,
+    ) {
         self.blockchain_context_service
             .ready()
             .await
@@ -474,28 +537,33 @@ impl super::BlockchainManager {
             }))
             .await
             .expect(PANIC_CRITICAL_SERVICE_ERROR);
+    }
 
+    /// Batch writes the [`VerifiedBlockInformation`]s to the database.
+    ///
+    /// The blocks must be sequential.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if any internal service returns an unexpected error that we cannot
+    /// recover from.
+    async fn batch_add_valid_block_to_blockchain_database(
+        &mut self,
+        blocks: Vec<VerifiedBlockInformation>,
+    ) {
         self.blockchain_write_handle
             .ready()
             .await
             .expect(PANIC_CRITICAL_SERVICE_ERROR)
-            .call(BlockchainWriteRequest::WriteBlock(verified_block))
-            .await
-            .expect(PANIC_CRITICAL_SERVICE_ERROR);
-
-        self.txpool_write_handle
-            .ready()
-            .await
-            .expect(PANIC_CRITICAL_SERVICE_ERROR)
-            .call(TxpoolWriteRequest::NewBlock { spent_key_images })
+            .call(BlockchainWriteRequest::BatchWriteBlocks(blocks))
             .await
             .expect(PANIC_CRITICAL_SERVICE_ERROR);
     }
 }
 
 /// The result from successfully adding an alt-block.
 enum AddAltBlock {
-    /// The alt-block was cached or was already present in the DB.
+    /// The alt-block was cached.
     Cached,
     /// The chain was reorged.
     Reorged,