fix: disable steam scan when scanning past blocks

Author: Ludo Galabru

components/chainhook-cli/src/cli/mod.rs

@@ -540,7 +540,7 @@ async fn handle_command(opts: Opts, ctx: Context) -> Result<(), String> {
                         };
 
                         scan_bitcoin_chainstate_via_http_using_predicate(
-                            predicate_spec,
+                            &predicate_spec,
                             &config,
                             &ctx,
                         )
@@ -560,7 +560,7 @@ async fn handle_command(opts: Opts, ctx: Context) -> Result<(), String> {
                         };
 
                         scan_stacks_chainstate_via_csv_using_predicate(
-                            predicate_spec,
+                            &predicate_spec,
                             &mut config,
                             &ctx,
                         )

components/chainhook-cli/src/scan/bitcoin.rs

@@ -27,7 +27,7 @@ use chainhook_types::{BitcoinChainEvent, BitcoinChainUpdatedWithBlocksData};
 use std::collections::{BTreeMap, HashMap};
 
 pub async fn scan_bitcoin_chainstate_via_http_using_predicate(
-    predicate_spec: BitcoinChainhookSpecification,
+    predicate_spec: &BitcoinChainhookSpecification,
     config: &Config,
     ctx: &Context,
 ) -> Result<(), String> {
@@ -149,7 +149,7 @@ pub async fn scan_bitcoin_chainstate_via_http_using_predicate(
             // Only consider inscriptions in the interval specified
             let local_traverals = match inscriptions_cache.remove(&cursor) {
                 Some(entry) => entry,
-                None => continue
+                None => continue,
             };
             for (transaction_identifier, traversal_result) in local_traverals.into_iter() {
                 traversals.insert(transaction_identifier, traversal_result);

components/chainhook-cli/src/scan/stacks.rs

@@ -23,7 +23,7 @@ use chainhook_event_observer::{
 use chainhook_types::BlockIdentifier;
 
 pub async fn scan_stacks_chainstate_via_csv_using_predicate(
-    predicate_spec: StacksChainhookSpecification,
+    predicate_spec: &StacksChainhookSpecification,
     config: &mut Config,
     ctx: &Context,
 ) -> Result<BlockIdentifier, String> {

components/chainhook-cli/src/service/mod.rs

@@ -5,7 +5,9 @@ use crate::scan::stacks::scan_stacks_chainstate_via_csv_using_predicate;
 use chainhook_event_observer::chainhooks::types::{ChainhookConfig, ChainhookFullSpecification};
 
 use chainhook_event_observer::chainhooks::types::ChainhookSpecification;
-use chainhook_event_observer::observer::{start_event_observer, ApiKey, ObserverEvent};
+use chainhook_event_observer::observer::{
+    start_event_observer, ApiKey, ObserverCommand, ObserverEvent,
+};
 use chainhook_event_observer::utils::Context;
 use chainhook_types::{BitcoinBlockSignaling, StacksBlockData, StacksChainEvent};
 use redis::{Commands, Connection};
@@ -115,10 +117,11 @@ impl Service {
 
         let context_cloned = self.ctx.clone();
         let event_observer_config_moved = event_observer_config.clone();
+        let observer_command_tx_moved = observer_command_tx.clone();
         let _ = std::thread::spawn(move || {
             let future = start_event_observer(
                 event_observer_config_moved,
-                observer_command_tx,
+                observer_command_tx_moved,
                 observer_command_rx,
                 Some(observer_event_tx),
                 context_cloned,
@@ -131,14 +134,16 @@ impl Service {
         let stacks_scan_pool = ThreadPool::new(STACKS_SCAN_THREAD_POOL_SIZE);
         let ctx = self.ctx.clone();
         let config = self.config.clone();
+        let observer_command_tx_moved = observer_command_tx.clone();
         let _ = hiro_system_kit::thread_named("Stacks scan runloop")
             .spawn(move || {
-                while let Ok(predicate_spec) = stacks_scan_op_rx.recv() {
+                while let Ok((predicate_spec, api_key)) = stacks_scan_op_rx.recv() {
                     let moved_ctx = ctx.clone();
                     let mut moved_config = config.clone();
+                    let observer_command_tx = observer_command_tx_moved.clone();
                     stacks_scan_pool.execute(move || {
                         let op = scan_stacks_chainstate_via_csv_using_predicate(
-                            predicate_spec,
+                            &predicate_spec,
                             &mut moved_config,
                             &moved_ctx,
                         );
@@ -156,6 +161,10 @@ impl Service {
                             moved_ctx.expect_logger(),
                             "Stacks chainstate scan completed up to block: {}", end_block.index
                         );
+                        let _ = observer_command_tx.send(ObserverCommand::EnablePredicate(
+                            ChainhookSpecification::Stacks(predicate_spec),
+                            api_key,
+                        ));
                     });
                 }
                 let res = stacks_scan_pool.join();
@@ -168,14 +177,16 @@ impl Service {
         let bitcoin_scan_pool = ThreadPool::new(BITCOIN_SCAN_THREAD_POOL_SIZE);
         let ctx = self.ctx.clone();
         let config = self.config.clone();
+        let moved_observer_command_tx = observer_command_tx.clone();
         let _ = hiro_system_kit::thread_named("Bitcoin scan runloop")
             .spawn(move || {
-                while let Ok(predicate_spec) = bitcoin_scan_op_rx.recv() {
+                while let Ok((predicate_spec, api_key)) = bitcoin_scan_op_rx.recv() {
                     let moved_ctx = ctx.clone();
                     let moved_config = config.clone();
+                    let observer_command_tx = moved_observer_command_tx.clone();
                     bitcoin_scan_pool.execute(move || {
                         let op = scan_bitcoin_chainstate_via_http_using_predicate(
-                            predicate_spec,
+                            &predicate_spec,
                             &moved_config,
                             &moved_ctx,
                         );
@@ -189,6 +200,10 @@ impl Service {
                                 );
                             }
                         };
+                        let _ = observer_command_tx.send(ObserverCommand::EnablePredicate(
+                            ChainhookSpecification::Bitcoin(predicate_spec),
+                            api_key,
+                        ));
                     });
                 }
                 let res = bitcoin_scan_pool.join();
@@ -219,7 +234,7 @@ impl Service {
                 }
             };
             match event {
-                ObserverEvent::HookRegistered(chainhook) => {
+                ObserverEvent::HookRegistered(chainhook, api_key) => {
                     // If start block specified, use it.
                     // I no start block specified, depending on the nature the hook, we'd like to retrieve:
                     // - contract-id
@@ -243,10 +258,10 @@ impl Service {
                     }
                     match chainhook {
                         ChainhookSpecification::Stacks(predicate_spec) => {
-                            let _ = stacks_scan_op_tx.send(predicate_spec);
+                            let _ = stacks_scan_op_tx.send((predicate_spec, api_key));
                         }
                         ChainhookSpecification::Bitcoin(predicate_spec) => {
-                            let _ = bitcoin_scan_op_tx.send(predicate_spec);
+                            let _ = bitcoin_scan_op_tx.send((predicate_spec, api_key));
                         }
                     }
                 }

components/chainhook-event-observer/src/chainhooks/types.rs

@@ -11,7 +11,7 @@ use schemars::JsonSchema;
 
 use crate::observer::ApiKey;
 
-#[derive(Clone, Debug, JsonSchema)]
+#[derive(Clone, Debug)]
 pub struct ChainhookConfig {
     pub stacks_chainhooks: Vec<StacksChainhookSpecification>,
     pub bitcoin_chainhooks: Vec<BitcoinChainhookSpecification>,
@@ -68,6 +68,30 @@ impl ChainhookConfig {
         Ok(spec)
     }
 
+    pub fn enable_specification(
+        &mut self,
+        predicate_spec: &ChainhookSpecification,
+    ) {
+        match predicate_spec {
+            ChainhookSpecification::Stacks(spec_to_enable) => {
+                for spec in self.stacks_chainhooks.iter_mut() {
+                    if spec.uuid.eq(&spec_to_enable.uuid) {
+                        spec.enabled = true;
+                        break;
+                    }
+                }
+            }
+            ChainhookSpecification::Bitcoin(spec_to_enable) => {
+                for spec in self.bitcoin_chainhooks.iter_mut() {
+                    if spec.uuid.eq(&spec_to_enable.uuid) {
+                        spec.enabled = true;
+                        break;
+                    }
+                }
+            }
+        };
+    }
+
     pub fn register_specification(&mut self, spec: ChainhookSpecification) -> Result<(), String> {
         match spec {
             ChainhookSpecification::Stacks(spec) => {
@@ -131,7 +155,7 @@ impl Serialize for ChainhookConfig {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "snake_case")]
 pub enum ChainhookSpecification {
     Bitcoin(BitcoinChainhookSpecification),
@@ -201,7 +225,7 @@ impl ChainhookSpecification {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct BitcoinChainhookSpecification {
     pub uuid: String,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -221,6 +245,7 @@ pub struct BitcoinChainhookSpecification {
     pub include_inputs: bool,
     pub include_outputs: bool,
     pub include_witness: bool,
+    pub enabled: bool,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
@@ -291,6 +316,7 @@ impl BitcoinChainhookFullSpecification {
             include_inputs: spec.include_inputs.unwrap_or(false),
             include_outputs: spec.include_outputs.unwrap_or(false),
             include_witness: spec.include_witness.unwrap_or(false),
+            enabled: false,
         })
     }
 }
@@ -349,6 +375,7 @@ impl StacksChainhookFullSpecification {
             expire_after_occurrence: spec.expire_after_occurrence,
             predicate: spec.predicate,
             action: spec.action,
+            enabled: false,
         })
     }
 }
@@ -645,7 +672,7 @@ pub enum BlockIdentifierHashRule {
     BuildsOff(String),
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct StacksChainhookSpecification {
     pub uuid: String,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -666,6 +693,7 @@ pub struct StacksChainhookSpecification {
     #[serde(rename = "predicate")]
     pub predicate: StacksPredicate,
     pub action: HookAction,
+    pub enabled: bool,
 }
 
 impl StacksChainhookSpecification {

components/chainhook-event-observer/src/hord/mod.rs

@@ -198,7 +198,11 @@ pub fn update_storage_and_augment_bitcoin_block_with_inscription_reveal_data(
                     Some(traversal) => traversal,
                     None => {
                         ctx.try_log(|logger| {
-                            slog::info!(logger, "Unable to retrieve cached inscription data for inscription {}", new_tx.transaction_identifier.hash);
+                            slog::info!(
+                                logger,
+                                "Unable to retrieve cached inscription data for inscription {}",
+                                new_tx.transaction_identifier.hash
+                            );
                         });
                         ordinals_events_indexes_to_discard.push_front(ordinal_event_index);
                         continue;