chore: refactor BlockBytesCursor usage

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

@@ -24,11 +24,11 @@ use ordhook::core::protocol::inscription_parsing::parse_inscriptions_and_standar
 use ordhook::core::protocol::satoshi_numbering::compute_satoshi_number;
 use ordhook::db::{
     delete_data_in_ordhook_db, find_all_inscription_transfers, find_all_inscriptions_in_block,
-    find_all_transfers_in_block, find_inscription_with_id, find_last_block_inserted,
-    find_latest_inscription_block_height, find_lazy_block_at_block_height, find_missing_blocks,
+    find_all_transfers_in_block, find_block_bytes_at_block_height, find_inscription_with_id,
+    find_last_block_inserted, find_latest_inscription_block_height, find_missing_blocks,
     get_default_ordhook_db_file_path, initialize_ordhook_db, open_ordhook_db_conn_rocks_db_loop,
     open_readonly_ordhook_db_conn, open_readonly_ordhook_db_conn_rocks_db,
-    open_readwrite_ordhook_db_conn,
+    open_readwrite_ordhook_db_conn, BlockBytesCursor,
 };
 use ordhook::download::download_ordinals_dataset_if_required;
 use ordhook::scan::bitcoin::scan_bitcoin_chainstate_via_rpc_using_predicate;
@@ -796,9 +796,10 @@ async fn handle_command(opts: Opts, ctx: &Context) -> Result<(), String> {
                         ctx,
                     );
                     for i in cmd.get_blocks().into_iter() {
-                        let block =
-                            find_lazy_block_at_block_height(i as u32, 10, false, &blocks_db, ctx)
+                        let block_bytes =
+                            find_block_bytes_at_block_height(i as u32, 10, &blocks_db, ctx)
                                 .expect("unable to retrieve block {i}");
+                        let block = BlockBytesCursor::new(&block_bytes);
                         info!(ctx.expect_logger(), "--------------------");
                         info!(ctx.expect_logger(), "Block: {i}");
                         for tx in block.iter_tx() {

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

@@ -14,15 +14,15 @@ use chainhook_sdk::{
 
 use crate::{
     config::{Config, LogConfig},
-    db::{find_lazy_block_at_block_height, open_ordhook_db_conn_rocks_db_loop},
+    db::{find_pinned_block_bytes_at_block_height, open_ordhook_db_conn_rocks_db_loop},
 };
 
 use crate::db::{
     find_last_block_inserted, find_latest_inscription_block_height, initialize_ordhook_db,
     open_readonly_ordhook_db_conn,
 };
 
-use crate::db::LazyBlockTransaction;
+use crate::db::TransactionBytesCursor;
 
 #[derive(Clone, Debug)]
 pub struct OrdhookConfig {
@@ -44,11 +44,11 @@ pub fn new_traversals_cache(
 
 pub fn new_traversals_lazy_cache(
     cache_size: usize,
-) -> DashMap<(u32, [u8; 8]), LazyBlockTransaction, BuildHasherDefault<FxHasher>> {
+) -> DashMap<(u32, [u8; 8]), TransactionBytesCursor, BuildHasherDefault<FxHasher>> {
     let hasher = FxBuildHasher::default();
     DashMap::with_capacity_and_hasher(
         ((cache_size.saturating_sub(500)) * 1000 * 1000)
-            .div(LazyBlockTransaction::get_average_bytes_size()),
+            .div(TransactionBytesCursor::get_average_bytes_size()),
         hasher,
     )
 }
@@ -139,7 +139,7 @@ pub fn should_sync_ordhook_db(
 
     match find_latest_inscription_block_height(&inscriptions_db_conn, ctx)? {
         Some(height) => {
-            if find_lazy_block_at_block_height(height as u32, 3, false, &blocks_db, &ctx).is_none()
+            if find_pinned_block_bytes_at_block_height(height as u32, 3, &blocks_db, &ctx).is_none()
             {
                 start_block = start_block.min(height);
             } else {

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

@@ -10,7 +10,7 @@ use std::time::Duration;
 use tokio::task::JoinSet;
 
 use crate::config::Config;
-use crate::db::LazyBlock;
+use crate::db::BlockBytesCursor;
 
 use chainhook_sdk::indexer::bitcoin::{
     build_http_client, parse_downloaded_block, try_download_block_bytes_with_retry,
@@ -19,7 +19,7 @@ use chainhook_sdk::indexer::bitcoin::{
 use super::protocol::inscription_parsing::parse_inscriptions_and_standardize_block;
 
 pub enum PostProcessorCommand {
-    ProcessBlocks(Vec<(u64, LazyBlock)>, Vec<BitcoinBlockData>),
+    ProcessBlocks(Vec<(u64, Vec<u8>)>, Vec<BitcoinBlockData>),
     Terminate,
 }
 
@@ -111,7 +111,7 @@ pub async fn download_and_pipeline_blocks(
                 while let Ok(Some(block_bytes)) = rx.recv() {
                     let raw_block_data =
                         parse_downloaded_block(block_bytes).expect("unable to parse block");
-                    let compressed_block = LazyBlock::from_full_block(&raw_block_data)
+                    let compressed_block = BlockBytesCursor::from_full_block(&raw_block_data)
                         .expect("unable to compress block");
                     let block_height = raw_block_data.height as u64;
                     let block_data = if block_height >= start_sequencing_blocks_at_height {
@@ -195,9 +195,9 @@ pub async fn download_and_pipeline_blocks(
                 let mut ooo_compacted_blocks = vec![];
                 for (block_height, block_opt, compacted_block) in new_blocks.into_iter() {
                     if let Some(block) = block_opt {
-                        inbox.insert(block_height, (block, compacted_block));
+                        inbox.insert(block_height, (block, compacted_block.to_vec()));
                     } else {
-                        ooo_compacted_blocks.push((block_height, compacted_block));
+                        ooo_compacted_blocks.push((block_height, compacted_block.to_vec()));
                     }
                 }
 

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

@@ -9,7 +9,7 @@ use std::{
 use crate::{
     config::Config,
     core::pipeline::{PostProcessorCommand, PostProcessorController, PostProcessorEvent},
-    db::{insert_entry_in_blocks, open_ordhook_db_conn_rocks_db_loop, LazyBlock},
+    db::{insert_entry_in_blocks, open_ordhook_db_conn_rocks_db_loop},
 };
 
 pub fn start_block_archiving_processor(
@@ -72,7 +72,7 @@ pub fn start_block_archiving_processor(
 }
 
 pub fn store_compacted_blocks(
-    mut compacted_blocks: Vec<(u64, LazyBlock)>,
+    mut compacted_blocks: Vec<(u64, Vec<u8>)>,
     update_tip: bool,
     blocks_db_rw: &DB,
     ctx: &Context,

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

@@ -38,7 +38,7 @@ use crate::{
     },
 };
 
-use crate::db::{LazyBlockTransaction, TraversalResult};
+use crate::db::{TransactionBytesCursor, TraversalResult};
 
 use crate::{
     config::Config,
@@ -162,7 +162,7 @@ pub fn start_inscription_indexing_processor(
 pub fn process_blocks(
     next_blocks: &mut Vec<BitcoinBlockData>,
     sequence_cursor: &mut SequenceCursor,
-    cache_l2: &Arc<DashMap<(u32, [u8; 8]), LazyBlockTransaction, BuildHasherDefault<FxHasher>>>,
+    cache_l2: &Arc<DashMap<(u32, [u8; 8]), TransactionBytesCursor, BuildHasherDefault<FxHasher>>>,
     inscriptions_db_conn_rw: &mut Connection,
     ordhook_config: &OrdhookConfig,
     post_processor: &Option<Sender<BitcoinBlockData>>,
@@ -259,7 +259,7 @@ pub fn process_block(
     next_blocks: &Vec<BitcoinBlockData>,
     sequence_cursor: &mut SequenceCursor,
     cache_l1: &mut BTreeMap<(TransactionIdentifier, usize), TraversalResult>,
-    cache_l2: &Arc<DashMap<(u32, [u8; 8]), LazyBlockTransaction, BuildHasherDefault<FxHasher>>>,
+    cache_l2: &Arc<DashMap<(u32, [u8; 8]), TransactionBytesCursor, BuildHasherDefault<FxHasher>>>,
     inscriptions_db_tx: &Transaction,
     ordhook_config: &OrdhookConfig,
     ctx: &Context,

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

@@ -23,7 +23,7 @@ use crate::{
         find_blessed_inscription_with_ordinal_number,
         find_latest_cursed_inscription_number_at_block_height,
         find_latest_inscription_number_at_block_height, format_satpoint_to_watch,
-        update_inscriptions_with_block, LazyBlockTransaction, TraversalResult,
+        update_inscriptions_with_block, TransactionBytesCursor, TraversalResult,
     },
     ord::height::Height,
 };
@@ -67,7 +67,7 @@ pub fn parallelize_inscription_data_computations(
     block: &BitcoinBlockData,
     next_blocks: &Vec<BitcoinBlockData>,
     cache_l1: &mut BTreeMap<(TransactionIdentifier, usize), TraversalResult>,
-    cache_l2: &Arc<DashMap<(u32, [u8; 8]), LazyBlockTransaction, BuildHasherDefault<FxHasher>>>,
+    cache_l2: &Arc<DashMap<(u32, [u8; 8]), TransactionBytesCursor, BuildHasherDefault<FxHasher>>>,
     inscriptions_db_tx: &Transaction,
     ordhook_config: &OrdhookConfig,
     ctx: &Context,

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

@@ -7,10 +7,11 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use crate::db::{
-    find_lazy_block_at_block_height, open_ordhook_db_conn_rocks_db_loop, TransferData,
+    find_pinned_block_bytes_at_block_height, open_ordhook_db_conn_rocks_db_loop, BlockBytesCursor,
+    TransferData,
 };
 
-use crate::db::{LazyBlockTransaction, TraversalResult};
+use crate::db::{TransactionBytesCursor, TraversalResult};
 use crate::ord::height::Height;
 
 pub fn compute_satoshi_number(
@@ -20,7 +21,7 @@ pub fn compute_satoshi_number(
     inscription_input_index: usize,
     inscription_number: i64,
     traversals_cache: &Arc<
-        DashMap<(u32, [u8; 8]), LazyBlockTransaction, BuildHasherDefault<FxHasher>>,
+        DashMap<(u32, [u8; 8]), TransactionBytesCursor, BuildHasherDefault<FxHasher>>,
     >,
     ctx: &Context,
 ) -> Result<TraversalResult, String> {
@@ -30,7 +31,7 @@ pub fn compute_satoshi_number(
     let mut ordinal_block_number = block_identifier.index as u32;
     let txid = transaction_identifier.get_8_hash_bytes();
 
-    let mut blocks_db = open_ordhook_db_conn_rocks_db_loop(false, &blocks_db_dir, &ctx);
+    let blocks_db = open_ordhook_db_conn_rocks_db_loop(false, &blocks_db_dir, &ctx);
 
     let (sats_ranges, inscription_offset_cross_outputs) = match traversals_cache
         .get(&(block_identifier.index as u32, txid.clone()))
@@ -42,26 +43,15 @@ pub fn compute_satoshi_number(
                 tx.get_cumulated_sats_in_until_input_index(inscription_input_index),
             )
         }
-        None => {
-            let mut attempt = 0;
-            loop {
-                match find_lazy_block_at_block_height(
-                    ordinal_block_number,
-                    3,
-                    false,
-                    &blocks_db,
-                    &ctx,
-                ) {
-                    None => {
-                        if attempt < 3 {
-                            attempt += 1;
-                            blocks_db =
-                                open_ordhook_db_conn_rocks_db_loop(false, &blocks_db_dir, &ctx);
-                        } else {
-                            return Err(format!("block #{ordinal_block_number} not in database"));
-                        }
-                    }
-                    Some(block) => match block.find_and_serialize_transaction_with_txid(&txid) {
+        None => loop {
+            match find_pinned_block_bytes_at_block_height(ordinal_block_number, 3, &blocks_db, &ctx)
+            {
+                None => {
+                    return Err(format!("block #{ordinal_block_number} not in database"));
+                }
+                Some(block_bytes) => {
+                    let cursor = BlockBytesCursor::new(&block_bytes.as_ref());
+                    match cursor.find_and_serialize_transaction_with_txid(&txid) {
                         Some(tx) => {
                             let sats_ranges = tx.get_sat_ranges();
                             let inscription_offset_cross_outputs =
@@ -70,10 +60,10 @@ pub fn compute_satoshi_number(
                             break (sats_ranges, inscription_offset_cross_outputs);
                         }
                         None => return Err(format!("txid not in block #{ordinal_block_number}")),
-                    },
+                    }
                 }
             }
-        }
+        },
     };
 
     for (i, (min, max)) in sats_ranges.into_iter().enumerate() {
@@ -158,30 +148,22 @@ pub fn compute_satoshi_number(
             }
         }
 
-        let lazy_block = {
-            let mut attempt = 0;
+        let pinned_block_bytes = {
             loop {
-                match find_lazy_block_at_block_height(
+                match find_pinned_block_bytes_at_block_height(
                     ordinal_block_number,
                     3,
-                    false,
                     &blocks_db,
                     &ctx,
                 ) {
                     Some(block) => break block,
                     None => {
-                        if attempt < 3 {
-                            attempt += 1;
-                            blocks_db =
-                                open_ordhook_db_conn_rocks_db_loop(false, &blocks_db_dir, &ctx);
-                        } else {
-                            return Err(format!("block #{ordinal_block_number} not in database"));
-                        }
+                        return Err(format!("block #{ordinal_block_number} not in database"));
                     }
                 }
             }
         };
-
+        let lazy_block = BlockBytesCursor::new(pinned_block_bytes.as_ref());
         let coinbase_txid = lazy_block.get_coinbase_txid();
         let txid = tx_cursor.0;