feat: wait for bitcoind to be at chain tip before starting service (#364)

* feat: wait for bitcoind to be at chain tip before starting service

* fix: reset confirmations

* chore: more logs

Author: rafaelcr

components/ordhook-core/src/service/mod.rs

@@ -35,6 +35,7 @@ use crate::db::{drop_block_data_from_all_dbs, open_all_dbs_rw};
 use crate::scan::bitcoin::process_block_with_predicates;
 use crate::service::observers::create_and_consolidate_chainhook_config_with_predicates;
 use crate::service::runloops::start_bitcoin_scan_runloop;
+use crate::utils::bitcoind::bitcoind_wait_for_chain_tip;
 use crate::utils::monitoring::{start_serving_prometheus_metrics, PrometheusMonitoring};
 use crate::{try_debug, try_error, try_info};
 use chainhook_sdk::chainhooks::bitcoin::BitcoinChainhookOccurrencePayload;
@@ -404,6 +405,7 @@ impl Service {
     }
 
     pub async fn check_blocks_db_integrity(&mut self) -> Result<(), String> {
+        bitcoind_wait_for_chain_tip(&self.config, &self.ctx);
         let (tip, missing_blocks) = {
             let blocks_db = open_blocks_db_with_retry(false, &self.config, &self.ctx);
 
@@ -446,7 +448,10 @@ impl Service {
         &self,
         block_post_processor: Option<crossbeam_channel::Sender<BitcoinBlockData>>,
     ) -> Result<(), String> {
-        // 1: Catch up blocks DB so it is at the same height as the ordinals DB.
+        // 0: Make sure bitcoind is synchronized.
+        bitcoind_wait_for_chain_tip(&self.config, &self.ctx);
+
+        // 1: Catch up blocks DB so it is at least at the same height as the ordinals DB.
         if let Some((start_block, end_block)) = should_sync_rocks_db(&self.config, &self.ctx)? {
             let blocks_post_processor = start_block_archiving_processor(
                 &self.config,
@@ -472,7 +477,8 @@ impl Service {
             .await?;
         }
 
-        // 2: Catch up ordinals DB until it reaches bitcoind block height. This will also advance blocks DB.
+        // 2: Catch up ordinals DB until it reaches bitcoind block height. This will also advance blocks DB and BRC-20 DB if
+        // enabled.
         let mut last_block_processed = 0;
         while let Some((start_block, end_block, speed)) =
             should_sync_ordhook_db(&self.config, &self.ctx)?
@@ -502,7 +508,6 @@ impl Service {
                 &self.ctx,
             )
             .await?;
-
             last_block_processed = end_block;
         }
 

components/ordhook-core/src/utils/bitcoind.rs

@@ -1,9 +1,11 @@
+use std::{thread::sleep, time::Duration};
+
 use chainhook_sdk::{
     bitcoincore_rpc::{Auth, Client, RpcApi},
     utils::Context,
 };
 
-use crate::{config::Config, try_error};
+use crate::{config::Config, try_error, try_info};
 
 fn bitcoind_get_client(config: &Config, ctx: &Context) -> Client {
     loop {
@@ -16,8 +18,8 @@ fn bitcoind_get_client(config: &Config, ctx: &Context) -> Client {
                 return con;
             }
             Err(e) => {
-                try_error!(ctx, "bitcoind unable to get client: {}", e.to_string());
-                std::thread::sleep(std::time::Duration::from_secs(1));
+                try_error!(ctx, "bitcoind: Unable to get client: {}", e.to_string());
+                sleep(Duration::from_secs(1));
             }
         }
     }
@@ -34,11 +36,44 @@ pub fn bitcoind_get_block_height(config: &Config, ctx: &Context) -> u64 {
             Err(e) => {
                 try_error!(
                     ctx,
-                    "bitcoind unable to get block height: {}",
+                    "bitcoind: Unable to get block height: {}",
+                    e.to_string()
+                );
+                sleep(Duration::from_secs(1));
+            }
+        };
+    }
+}
+
+/// Checks if bitcoind is still synchronizing blocks and waits until it's finished if that is the case.
+pub fn bitcoind_wait_for_chain_tip(config: &Config, ctx: &Context) {
+    let bitcoin_rpc = bitcoind_get_client(config, ctx);
+    let mut confirmations = 0;
+    loop {
+        match bitcoin_rpc.get_blockchain_info() {
+            Ok(result) => {
+                if result.initial_block_download == false && result.blocks == result.headers {
+                    confirmations += 1;
+                    // Wait for 10 confirmations before declaring node is at chain tip, just in case it's still connecting to
+                    // peers.
+                    if confirmations == 10 {
+                        try_info!(ctx, "bitcoind: Chain tip reached");
+                        return;
+                    }
+                    try_info!(ctx, "bitcoind: Verifying chain tip");
+                } else {
+                    confirmations = 0;
+                    try_info!(ctx, "bitcoind: Node has not reached chain tip, trying again");
+                }
+            }
+            Err(e) => {
+                try_error!(
+                    ctx,
+                    "bitcoind: Unable to check for chain tip: {}",
                     e.to_string()
                 );
-                std::thread::sleep(std::time::Duration::from_secs(1));
             }
         };
+        sleep(Duration::from_secs(1));
     }
 }