[WIP] Stream best blocks to the relay instead of pushing them

crates/rbuilder/src/bin/dummy-builder.rs

@@ -5,11 +5,14 @@
 //! This is NOT intended to be run in production so it has no nice configuration, poor error checking and some hardcoded values.
 use std::{path::PathBuf, sync::Arc, thread::sleep, time::Duration};
 
+use alloy_primitives::U256;
 use jsonrpsee::RpcModule;
 use rbuilder::{
     beacon_api_client::Client,
     building::{
         builders::{
+            best_block_store::BestBlockTracker,
+            best_block_store::GlobalBestBlockStore,
             block_building_helper::{BlockBuildingHelper, BlockBuildingHelperFromProvider},
             BlockBuildingAlgorithm, BlockBuildingAlgorithmInput, OrderConsumer,
             UnfinishedBlockBuildingSink, UnfinishedBlockBuildingSinkFactory,
@@ -47,7 +50,7 @@ use tokio::{
     sync::{broadcast, mpsc},
 };
 use tokio_util::sync::CancellationToken;
-use tracing::{info, level_filters::LevelFilter};
+use tracing::{error, info, level_filters::LevelFilter};
 
 const RETH_DB_PATH: &str = DEFAULT_RETH_DB_PATH;
 
@@ -110,7 +113,9 @@ async fn main() -> eyre::Result<()> {
         global_cancellation: cancel.clone(),
         extra_rpc: RpcModule::new(()),
         sink_factory: Box::new(TraceBlockSinkFactory {}),
-        builders: vec![Arc::new(DummyBuildingAlgorithm::new(10))],
+        builders: vec![Arc::new(
+            DummyBuildingAlgorithm::new(10, GlobalBestBlockStore::new()).await,
+        )],
         run_sparse_trie_prefetcher: false,
         orderpool_sender,
         orderpool_receiver,
@@ -157,7 +162,6 @@ impl UnfinishedBlockBuildingSink for TracingBlockSink {
         false
     }
 }
-
 ////////////////////////////
 /// BUILDING ALGORITHM
 ////////////////////////////
@@ -168,13 +172,18 @@ impl UnfinishedBlockBuildingSink for TracingBlockSink {
 struct DummyBuildingAlgorithm {
     /// Amnount of used orders to build a block
     orders_to_use: usize,
+    best_block_tracker: BestBlockTracker,
 }
 
 const ORDER_POLLING_PERIOD: Duration = Duration::from_millis(10);
 const BUILDER_NAME: &str = "DUMMY";
 impl DummyBuildingAlgorithm {
-    pub fn new(orders_to_use: usize) -> Self {
-        Self { orders_to_use }
+    pub async fn new(orders_to_use: usize, best_block_store: GlobalBestBlockStore) -> Self {
+        let best_block_tracker = BestBlockTracker::new(best_block_store);
+        Self {
+            orders_to_use,
+            best_block_tracker,
+        }
     }
 
     fn wait_for_orders(
@@ -247,7 +256,19 @@ where
             let block = self
                 .build_block(orders, input.provider, &input.ctx)
                 .unwrap();
-            input.sink.new_block(block);
+
+            match block.finalize_block(Some(U256::from(0))) {
+                Ok(res) => {
+                    // block on the async operation
+                    tokio::task::block_in_place(|| {
+                        tokio::runtime::Handle::current()
+                            .block_on(self.best_block_tracker.try_and_update(res.block))
+                    });
+                }
+                Err(e) => {
+                    error!("Error on finalize_block on DummyBuildingAlgorithm: {:?}", e);
+                }
+            }
         }
     }
 }