fix: additional adjustments on pointers

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,57 @@ 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;
+    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(
     input_index: usize,
-    offset_intra_input: u64,
     inputs: &Vec<u64>,
     outputs: &Vec<u64>,
-    pointer_from_inscription: u64,
+    relative_pointer_value: u64,
 ) -> 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;
-    }
-    offset_cross_inputs += offset_intra_input;
-    offset_cross_inputs += pointer_from_inscription;
+        absolute_offset_in_inputs += input_value;
+    }    
+    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,54 +212,52 @@ 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, &vec![20, 30, 45], &vec![20, 30, 45], 10),
         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, &vec![20, 30, 45], &vec![20, 30, 45], 20),
         SatPosition::Output((1, 0))
     );
     assert_eq!(
-        compute_next_satpoint_data(1, 5, &vec![20, 30, 45], &vec![20, 30, 45], 0),
+        compute_next_satpoint_data(1, &vec![20, 30, 45], &vec![20, 30, 45], 25),
         SatPosition::Output((1, 5))
     );
     assert_eq!(
-        compute_next_satpoint_data(1, 6, &vec![20, 30, 45], &vec![20, 5, 45], 0),
+        compute_next_satpoint_data(1, &vec![20, 30, 45], &vec![20, 5, 45], 26),
         SatPosition::Output((2, 1))
     );
     assert_eq!(
-        compute_next_satpoint_data(1, 10, &vec![10, 10, 10], &vec![30], 0),
+        compute_next_satpoint_data(1, &vec![10, 10, 10], &vec![30], 20),
         SatPosition::Output((0, 20))
     );
     assert_eq!(
-        compute_next_satpoint_data(0, 30, &vec![10, 10, 10], &vec![30], 0),
+        compute_next_satpoint_data(0, &vec![10, 10, 10], &vec![30], 30),
         SatPosition::Fee(0)
     );
     assert_eq!(
-        compute_next_satpoint_data(0, 0, &vec![10, 10, 10], &vec![30], 0),
+        compute_next_satpoint_data(0, &vec![10, 10, 10], &vec![30], 0),
         SatPosition::Output((0, 0))
     );
     assert_eq!(
-        compute_next_satpoint_data(2, 45, &vec![20, 30, 45], &vec![20, 30, 45], 0),
+        compute_next_satpoint_data(2, &vec![20, 30, 45], &vec![20, 30, 45], 95),
         SatPosition::Fee(0)
     );
     assert_eq!(
         compute_next_satpoint_data(
             2,
-            0,
             &vec![1000, 600, 546, 63034],
             &vec![1600, 10000, 15000],
-            0
+            1600
         ),
         SatPosition::Output((1, 0))
     );
     assert_eq!(
         compute_next_satpoint_data(
             3,
-            0,
             &vec![6100, 148660, 103143, 7600],
             &vec![81434, 173995],
-            0
+            257903
         ),
         SatPosition::Fee(2474)
     );

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

@@ -83,7 +83,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,

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

@@ -19,7 +19,7 @@ use fxhash::FxHasher;
 use rusqlite::{Connection, Transaction};
 
 use crate::{
-    core::OrdhookConfig,
+    core::{resolve_absolute_pointer, OrdhookConfig},
     db::{
         find_blessed_inscription_with_ordinal_number, find_nth_classic_neg_number_at_block_height,
         find_nth_classic_pos_number_at_block_height, find_nth_jubilee_number_at_block_height,
@@ -366,6 +366,8 @@ fn get_transactions_to_process(
         find_all_inscriptions_in_block(&block.block_identifier.index, inscriptions_db_tx, ctx);
 
     for tx in block.transactions.iter().skip(1) {
+        let inputs = tx.metadata.inputs.iter().map(|i| i.previous_output.value).collect::<Vec<u64>>();
+
         // Have a new inscription been revealed, if so, are looking at a re-inscription
         for ordinal_event in tx.metadata.ordinal_operations.iter() {
             let inscription_data = match ordinal_event {
@@ -374,10 +376,20 @@ fn get_transactions_to_process(
                     continue;
                 }
             };
+
+            let (input_index, relative_offset) = match inscription_data.inscription_pointer {
+                Some(pointer) => {
+                    resolve_absolute_pointer(&inputs, pointer)
+                }
+                None => {
+                    (inscription_data.inscription_input_index, 0)
+                }
+            };
+
             let key = (
                 tx.transaction_identifier.clone(),
-                inscription_data.inscription_input_index,
-                inscription_data.inscription_pointer,
+                input_index,
+                relative_offset,
             );
             if cache_l1.contains_key(&key) {
                 l1_cache_hits.push(key);
@@ -391,8 +403,8 @@ fn get_transactions_to_process(
             // Enqueue for traversals
             transactions_ids.push((
                 tx.transaction_identifier.clone(),
-                inscription_data.inscription_input_index,
-                inscription_data.inscription_pointer,
+                input_index,
+                relative_offset,
             ));
         }
     }
@@ -673,6 +685,8 @@ fn augment_transaction_with_ordinals_inscriptions_data(
     reinscriptions_data: &mut HashMap<u64, String>,
     ctx: &Context,
 ) -> bool {
+    let inputs = tx.metadata.inputs.iter().map(|i| i.previous_output.value).collect::<Vec<u64>>();
+
     let any_event = tx.metadata.ordinal_operations.is_empty() == false;
     let mut mutated_operations = vec![];
     mutated_operations.append(&mut tx.metadata.ordinal_operations);
@@ -685,12 +699,21 @@ fn augment_transaction_with_ordinals_inscriptions_data(
             OrdinalOperation::InscriptionTransferred(_) => continue,
         };
 
+        let (input_index, relative_offset) = match inscription.inscription_pointer {
+            Some(pointer) => {
+                resolve_absolute_pointer(&inputs, pointer)
+            }
+            None => {
+                (inscription.inscription_input_index, 0)
+            }
+        };
+
         let transaction_identifier = tx.transaction_identifier.clone();
         let inscription_id = format_inscription_id(&transaction_identifier, inscription_subindex);
         let traversal = match inscriptions_data.get(&(
             transaction_identifier,
-            inscription.inscription_input_index,
-            inscription.inscription_pointer,
+            input_index,
+            relative_offset,
         )) {
             Some(traversal) => traversal,
             None => {
@@ -746,8 +769,8 @@ fn augment_transaction_with_ordinals_inscriptions_data(
 
         let (destination, satpoint_post_transfer, output_value) = compute_satpoint_post_transfer(
             &&*tx,
-            traversal.inscription_input_index,
-            inscription.inscription_pointer,
+            input_index,
+            relative_offset,
             network,
             coinbase_txid,
             coinbase_subsidy,
@@ -825,6 +848,8 @@ fn consolidate_transaction_with_pre_computed_inscription_data(
     let mut mutated_operations = vec![];
     mutated_operations.append(&mut tx.metadata.ordinal_operations);
 
+    let inputs = tx.metadata.inputs.iter().map(|i| i.previous_output.value).collect::<Vec<u64>>();
+
     for operation in mutated_operations.iter_mut() {
         let inscription = match operation {
             OrdinalOperation::InscriptionRevealed(ref mut inscription) => inscription,
@@ -847,11 +872,19 @@ fn consolidate_transaction_with_pre_computed_inscription_data(
         inscription.inscription_fee = tx.metadata.fee;
         inscription.tx_index = tx_index;
 
+        let (input_index, relative_offset) = match inscription.inscription_pointer {
+            Some(pointer) => {
+                resolve_absolute_pointer(&inputs, pointer)
+            }
+            None => {
+                (traversal.inscription_input_index, 0)
+            }
+        };
         // Compute satpoint_post_inscription
         let (destination, satpoint_post_transfer, output_value) = compute_satpoint_post_transfer(
             tx,
-            traversal.inscription_input_index,
-            inscription.inscription_pointer,
+            input_index,
+            relative_offset,
             network,
             coinbase_txid,
             coinbase_subsidy,

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

@@ -82,7 +82,7 @@ pub fn compute_satpoint_post_transfer(
         .collect::<_>();
     let outputs = tx.metadata.outputs.iter().map(|o| o.value).collect::<_>();
     let post_transfer_data =
-        compute_next_satpoint_data(input_index, 0, &inputs, &outputs, inscription_pointer);
+        compute_next_satpoint_data(input_index, &inputs, &outputs, inscription_pointer);
 
     let (outpoint_post_transfer, offset_post_transfer, destination, post_transfer_output_value) =
         match post_transfer_data {