feat: jubilee support

.github/workflows/ci.yaml

@@ -109,6 +109,8 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           file: ./dockerfiles/components/ordhook.dockerfile
+          build-args: |
+            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
           # Only push if (there's a new release on main branch, or if building a non-main branch) and (Only run on non-PR events or only PRs that aren't from forks)

components/ordhook-cli/Cargo.toml

@@ -26,6 +26,9 @@ toml = { version = "0.5.6", features = ["preserve_order"], optional = true }
 ctrlc = { version = "3.2.2", optional = true }
 tcmalloc2 = { version = "0.1.2+2.13", optional = true }
 
+[target.'cfg(not(target_env = "msvc"))'.dependencies]
+tcmalloc2 = "0.1.2+2.13"
+
 [features]
 default = ["cli"]
 cli = ["clap", "clap_generate", "toml", "ctrlc", "hiro-system-kit/log"]

components/ordhook-cli/build.rs

@@ -0,0 +1,29 @@
+use std::process::Command;
+
+fn current_git_hash() -> Option<String> {
+    if option_env!("GIT_COMMIT") == None {
+        let commit = Command::new("git")
+            .arg("log")
+            .arg("-1")
+            .arg("--pretty=format:%h") // Abbreviated commit hash
+            .current_dir(env!("CARGO_MANIFEST_DIR"))
+            .output();
+
+        if let Ok(commit) = commit {
+            if let Ok(commit) = String::from_utf8(commit.stdout) {
+                return Some(commit);
+            }
+        }
+    } else {
+        return option_env!("GIT_COMMIT").map(String::from);
+    }
+
+    None
+}
+
+fn main() {
+    // note: add error checking yourself.
+    if let Some(git) = current_git_hash() {
+        println!("cargo:rustc-env=GIT_COMMIT={}", git);
+    }
+}

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

@@ -345,6 +345,9 @@ struct StartCommand {
     /// Check blocks integrity
     #[clap(long = "check-blocks-integrity")]
     pub block_integrity_check: bool,
+    /// Stream indexing to observers
+    #[clap(long = "stream-indexing")]
+    pub stream_indexing_to_observers: bool,
 }
 
 #[derive(Subcommand, PartialEq, Clone, Debug)]
@@ -725,8 +728,11 @@ async fn handle_command(opts: Opts, ctx: &Context) -> Result<(), String> {
                 }
 
                 let ordhook_config = config.get_ordhook_config();
-
-                info!(ctx.expect_logger(), "Starting service...",);
+                let version = env!("GIT_COMMIT");
+                info!(
+                    ctx.expect_logger(),
+                    "Starting service (git_commit = {})...", version
+                );
 
                 let start_block = match cmd.start_at_block {
                     Some(entry) => entry,
@@ -758,7 +764,12 @@ async fn handle_command(opts: Opts, ctx: &Context) -> Result<(), String> {
 
                 let mut service = Service::new(config, ctx.clone());
                 return service
-                    .run(predicates, None, cmd.block_integrity_check)
+                    .run(
+                        predicates,
+                        None,
+                        cmd.block_integrity_check,
+                        cmd.stream_indexing_to_observers,
+                    )
                     .await;
             }
         },
@@ -913,6 +924,16 @@ async fn handle_command(opts: Opts, ctx: &Context) -> Result<(), String> {
             let inscriptions_db_conn_rw =
                 open_readwrite_ordhook_db_conn(&config.expected_cache_path(), ctx)?;
 
+            println!(
+                "{} blocks will be deleted. Confirm? [Y/n]",
+                cmd.end_block - cmd.start_block + 1
+            );
+            let mut buffer = String::new();
+            std::io::stdin().read_line(&mut buffer).unwrap();
+            if buffer.starts_with('n') {
+                return Err("Deletion aborted".to_string());
+            }
+
             delete_data_in_ordhook_db(
                 cmd.start_block,
                 cmd.end_block,

components/ordhook-cli/src/main.rs

@@ -4,6 +4,10 @@ extern crate serde_derive;
 #[macro_use]
 extern crate hiro_system_kit;
 
+#[cfg(not(target_env = "msvc"))]
+#[global_allocator]
+static GLOBAL: tcmalloc2::TcMalloc = tcmalloc2::TcMalloc;
+
 pub mod cli;
 pub mod config;
 

components/ordhook-core/Cargo.toml

@@ -10,7 +10,7 @@ serde_json = "1"
 serde_derive = "1"
 hex = "0.4.3"
 rand = "0.8.5"
-chainhook-sdk = { version = "=0.12.2", features = ["zeromq"] }
+chainhook-sdk = { version = "=0.12.4", features = ["zeromq"] }
 # chainhook-sdk = { version = "=0.12.1", path = "../../../chainhook/components/chainhook-sdk", features = ["zeromq"] }
 hiro-system-kit = "0.3.1"
 reqwest = { version = "0.11", default-features = false, features = [

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

@@ -56,41 +56,63 @@ pub enum SatPosition {
     Fee(u64),
 }
 
+pub fn resolve_absolute_pointer(inputs: &Vec<u64>, absolute_pointer_value: u64) -> (usize, u64) {
+    let mut selected_index = 0;
+    let mut cumulated_input_value = 0;
+    // Check for overflow
+    let total: u64 = inputs.iter().sum();
+    if absolute_pointer_value > total {
+        return (0, 0);
+    }
+    // Identify the input + satoshi offset being inscribed
+    for (index, input_value) in inputs.iter().enumerate() {
+        if (cumulated_input_value + input_value) > absolute_pointer_value {
+            selected_index = index;
+            break;
+        }
+        cumulated_input_value += input_value;
+    }
+    let relative_pointer_value = absolute_pointer_value - cumulated_input_value;
+    (selected_index, relative_pointer_value)
+}
+
 pub fn compute_next_satpoint_data(
+    _tx_index: usize,
     input_index: usize,
-    offset_intra_input: u64,
     inputs: &Vec<u64>,
     outputs: &Vec<u64>,
-    pointer_from_inscription: u64,
+    relative_pointer_value: u64,
+    _ctx: Option<&Context>,
 ) -> SatPosition {
-    let mut offset_cross_inputs = 0;
+    let mut absolute_offset_in_inputs = 0;
     for (index, input_value) in inputs.iter().enumerate() {
         if index == input_index {
             break;
         }
-        offset_cross_inputs += input_value;
+        absolute_offset_in_inputs += input_value;
     }
-    offset_cross_inputs += offset_intra_input;
-    offset_cross_inputs += pointer_from_inscription;
+    absolute_offset_in_inputs += relative_pointer_value;
 
-    let mut offset_intra_outputs = 0;
-    let mut output_index = 0;
+    let mut absolute_offset_of_first_satoshi_in_selected_output = 0;
+    let mut selected_output_index = 0;
     let mut floating_bound = 0;
 
     for (index, output_value) in outputs.iter().enumerate() {
         floating_bound += output_value;
-        output_index = index;
-        if floating_bound > offset_cross_inputs {
+        selected_output_index = index;
+        if floating_bound > absolute_offset_in_inputs {
             break;
         }
-        offset_intra_outputs += output_value;
+        absolute_offset_of_first_satoshi_in_selected_output += output_value;
     }
 
-    if output_index == (outputs.len() - 1) && offset_cross_inputs >= floating_bound {
+    if selected_output_index == (outputs.len() - 1) && absolute_offset_in_inputs >= floating_bound {
         // Satoshi spent in fees
-        return SatPosition::Fee(offset_cross_inputs - floating_bound);
+        return SatPosition::Fee(absolute_offset_in_inputs - floating_bound);
     }
-    SatPosition::Output((output_index, (offset_cross_inputs - offset_intra_outputs)))
+    let relative_offset_in_selected_output =
+        absolute_offset_in_inputs - absolute_offset_of_first_satoshi_in_selected_output;
+    SatPosition::Output((selected_output_index, relative_offset_in_selected_output))
 }
 
 pub fn should_sync_rocks_db(config: &Config, ctx: &Context) -> Result<Option<(u64, u64)>, String> {
@@ -196,55 +218,57 @@ pub fn should_sync_ordhook_db(
 #[test]
 fn test_identify_next_output_index_destination() {
     assert_eq!(
-        compute_next_satpoint_data(0, 10, &vec![20, 30, 45], &vec![20, 30, 45], 0),
+        compute_next_satpoint_data(0, 0, &vec![20, 30, 45], &vec![20, 30, 45], 10, None),
         SatPosition::Output((0, 10))
     );
     assert_eq!(
-        compute_next_satpoint_data(0, 20, &vec![20, 30, 45], &vec![20, 30, 45], 0),
+        compute_next_satpoint_data(0, 0, &vec![20, 30, 45], &vec![20, 30, 45], 20, None),
         SatPosition::Output((1, 0))
     );
     assert_eq!(
-        compute_next_satpoint_data(1, 5, &vec![20, 30, 45], &vec![20, 30, 45], 0),
-        SatPosition::Output((1, 5))
+        compute_next_satpoint_data(0, 1, &vec![20, 30, 45], &vec![20, 30, 45], 25, None),
+        SatPosition::Output((1, 25))
     );
     assert_eq!(
-        compute_next_satpoint_data(1, 6, &vec![20, 30, 45], &vec![20, 5, 45], 0),
-        SatPosition::Output((2, 1))
+        compute_next_satpoint_data(0, 1, &vec![20, 30, 45], &vec![20, 5, 45], 26, None),
+        SatPosition::Output((2, 21))
     );
     assert_eq!(
-        compute_next_satpoint_data(1, 10, &vec![10, 10, 10], &vec![30], 0),
-        SatPosition::Output((0, 20))
+        compute_next_satpoint_data(0, 1, &vec![10, 10, 10], &vec![30], 20, None),
+        SatPosition::Fee(0)
     );
     assert_eq!(
-        compute_next_satpoint_data(0, 30, &vec![10, 10, 10], &vec![30], 0),
+        compute_next_satpoint_data(0, 0, &vec![10, 10, 10], &vec![30], 30, None),
         SatPosition::Fee(0)
     );
     assert_eq!(
-        compute_next_satpoint_data(0, 0, &vec![10, 10, 10], &vec![30], 0),
+        compute_next_satpoint_data(0, 0, &vec![10, 10, 10], &vec![30], 0, None),
         SatPosition::Output((0, 0))
     );
     assert_eq!(
-        compute_next_satpoint_data(2, 45, &vec![20, 30, 45], &vec![20, 30, 45], 0),
-        SatPosition::Fee(0)
+        compute_next_satpoint_data(0, 2, &vec![20, 30, 45], &vec![20, 30, 45], 95, None),
+        SatPosition::Fee(50)
     );
     assert_eq!(
         compute_next_satpoint_data(
-            2,
             0,
+            2,
             &vec![1000, 600, 546, 63034],
             &vec![1600, 10000, 15000],
-            0
+            1600,
+            None
         ),
-        SatPosition::Output((1, 0))
+        SatPosition::Output((1, 1600))
     );
     assert_eq!(
         compute_next_satpoint_data(
-            3,
             0,
+            3,
             &vec![6100, 148660, 103143, 7600],
             &vec![81434, 173995],
-            0
+            257903,
+            None
         ),
-        SatPosition::Fee(2474)
+        SatPosition::Fee(260377)
     );
 }

components/ordhook-core/src/core/pipeline/processors/inscription_indexing.rs

@@ -28,7 +28,7 @@ use crate::{
                 augment_block_with_ordinals_inscriptions_data_and_write_to_db_tx,
                 parallelize_inscription_data_computations, SequenceCursor,
             },
-            inscription_tracking::augment_block_with_ordinals_transfer_data,
+            satoshi_tracking::augment_block_with_ordinals_transfer_data,
         },
         OrdhookConfig,
     },

components/ordhook-core/src/core/pipeline/processors/transfers_recomputing.rs

@@ -12,11 +12,11 @@ use crate::{
         pipeline::{PostProcessorCommand, PostProcessorController, PostProcessorEvent},
         protocol::{
             inscription_sequencing::consolidate_block_with_pre_computed_ordinals_data,
-            inscription_tracking::augment_block_with_ordinals_transfer_data,
+            satoshi_tracking::augment_block_with_ordinals_transfer_data,
         },
     },
     db::{
-        insert_new_inscriptions_from_block_in_locations, open_readwrite_ordhook_db_conn,
+        insert_entries_from_block_in_inscriptions, open_readwrite_ordhook_db_conn,
         remove_entries_from_locations_at_block_height,
     },
 };
@@ -83,11 +83,7 @@ pub fn start_transfers_recomputing_processor(
                         &ctx,
                     );
 
-                    insert_new_inscriptions_from_block_in_locations(
-                        block,
-                        &inscriptions_db_tx,
-                        &ctx,
-                    );
+                    insert_entries_from_block_in_inscriptions(block, &inscriptions_db_tx, &ctx);
 
                     augment_block_with_ordinals_transfer_data(
                         block,

components/ordhook-core/src/core/protocol/inscription_parsing.rs

@@ -21,6 +21,11 @@ pub fn parse_inscriptions_from_witness(
     witness_bytes: Vec<Vec<u8>>,
     txid: &str,
 ) -> Option<Vec<OrdinalInscriptionRevealData>> {
+    // Efficient debugging: Isolate one specific transaction
+    // if !txid.eq("aa2ab56587c7d6609c95157e6dff37c5c3fa6531702f41229a289a5613887077") {
+    //     return None
+    // }
+
     let witness = Witness::from_slice(&witness_bytes);
     let tapscript = witness.tapscript()?;
     let envelopes: Vec<Envelope<Inscription>> = RawEnvelope::from_tapscript(tapscript, input_index)
@@ -83,7 +88,7 @@ pub fn parse_inscriptions_from_witness(
             inscription_input_index: input_index,
             tx_index: 0,
             inscription_output_value: 0,
-            inscription_pointer: envelope.payload.pointer().unwrap_or(0),
+            inscription_pointer: envelope.payload.pointer(),
             inscription_fee: 0,
             inscription_number: OrdinalInscriptionNumber::zero(),
             inscriber_address: None,