global: big snapshot

crates/brk_query/src/impl/block/info.rs

@@ -20,11 +20,11 @@ impl Query {
             return Err(Error::OutOfRange("Block height out of range".into()));
         }
 
-        let blockhash = indexer.vecs.block.height_to_blockhash.read_once(height)?;
-        let difficulty = indexer.vecs.block.height_to_difficulty.read_once(height)?;
-        let timestamp = indexer.vecs.block.height_to_timestamp.read_once(height)?;
-        let size = indexer.vecs.block.height_to_total_size.read_once(height)?;
-        let weight = indexer.vecs.block.height_to_weight.read_once(height)?;
+        let blockhash = indexer.vecs.blocks.blockhash.read_once(height)?;
+        let difficulty = indexer.vecs.blocks.difficulty.read_once(height)?;
+        let timestamp = indexer.vecs.blocks.timestamp.read_once(height)?;
+        let size = indexer.vecs.blocks.total_size.read_once(height)?;
+        let weight = indexer.vecs.blocks.weight.read_once(height)?;
         let tx_count = self.tx_count_at_height(height, max_height)?;
 
         Ok(BlockInfo {
@@ -75,8 +75,8 @@ impl Query {
         Height::from(
             self.indexer()
                 .vecs
-                .block
-                .height_to_blockhash
+                .blocks
+                .blockhash
                 .len()
                 .saturating_sub(1),
         )
@@ -86,15 +86,15 @@ impl Query {
         let indexer = self.indexer();
         let computer = self.computer();
 
-        let first_txindex = indexer.vecs.tx.height_to_first_txindex.read_once(height)?;
+        let first_txindex = indexer.vecs.transactions.first_txindex.read_once(height)?;
         let next_first_txindex = if height < max_height {
             indexer
                 .vecs
-                .tx
-                .height_to_first_txindex
+                .transactions
+                .first_txindex
                 .read_once(height.incremented())?
         } else {
-            TxIndex::from(computer.indexes.transaction.txindex_to_txindex.len())
+            TxIndex::from(computer.indexes.txindex.identity.len())
         };
 
         Ok((next_first_txindex.to_usize() - first_txindex.to_usize()) as u32)

crates/brk_query/src/impl/block/raw.rs

@@ -15,20 +15,13 @@ impl Query {
         let computer = self.computer();
         let reader = self.reader();
 
-        let max_height = Height::from(
-            indexer
-                .vecs
-                .block
-                .height_to_blockhash
-                .len()
-                .saturating_sub(1),
-        );
+        let max_height = Height::from(indexer.vecs.blocks.blockhash.len().saturating_sub(1));
         if height > max_height {
             return Err(Error::OutOfRange("Block height out of range".into()));
         }
 
-        let position = computer.positions.height_to_position.read_once(height)?;
-        let size = indexer.vecs.block.height_to_total_size.read_once(height)?;
+        let position = computer.positions.block_position.read_once(height)?;
+        let size = indexer.vecs.blocks.total_size.read_once(height)?;
 
         reader.read_raw_bytes(position, *size as usize)
     }

crates/brk_query/src/impl/block/status.rs

@@ -16,8 +16,8 @@ impl Query {
         let max_height = Height::from(
             indexer
                 .vecs
-                .block
-                .height_to_blockhash
+                .blocks
+                .blockhash
                 .len()
                 .saturating_sub(1),
         );
@@ -30,8 +30,8 @@ impl Query {
             Some(
                 indexer
                     .vecs
-                    .block
-                    .height_to_blockhash
+                    .blocks
+                    .blockhash
                     .read_once(height.incremented())?,
             )
         } else {

crates/brk_query/src/impl/block/timestamp.rs

@@ -24,15 +24,15 @@ impl Query {
         // Get first height of the target date
         let first_height_of_day = computer
             .indexes
-            .time
-            .dateindex_to_first_height
+            .dateindex
+            .first_height
             .read_once(dateindex)
             .unwrap_or(Height::from(0usize));
 
         let start: usize = usize::from(first_height_of_day).min(max_height_usize);
 
         // Use iterator for efficient sequential access
-        let mut timestamp_iter = indexer.vecs.block.height_to_timestamp.iter()?;
+        let mut timestamp_iter = indexer.vecs.blocks.timestamp.iter()?;
 
         // Search forward from start to find the last block <= target timestamp
         let mut best_height = start;
@@ -62,8 +62,8 @@ impl Query {
         let height = Height::from(best_height);
         let blockhash = indexer
             .vecs
-            .block
-            .height_to_blockhash
+            .blocks
+            .blockhash
             .iter()?
             .get_unwrap(height);
 

crates/brk_query/src/impl/block/txs.rs

@@ -31,13 +31,13 @@ impl Query {
             return Err(Error::OutOfRange("Block height out of range".into()));
         }
 
-        let first_txindex = indexer.vecs.tx.height_to_first_txindex.read_once(height)?;
+        let first_txindex = indexer.vecs.transactions.first_txindex.read_once(height)?;
         let next_first_txindex = indexer
             .vecs
-            .tx
-            .height_to_first_txindex
+            .transactions
+            .first_txindex
             .read_once(height.incremented())
-            .unwrap_or_else(|_| TxIndex::from(indexer.vecs.tx.txindex_to_txid.len()));
+            .unwrap_or_else(|_| TxIndex::from(indexer.vecs.transactions.txid.len()));
 
         let first: usize = first_txindex.into();
         let next: usize = next_first_txindex.into();
@@ -45,8 +45,8 @@ impl Query {
 
         let txids: Vec<Txid> = indexer
             .vecs
-            .tx
-            .txindex_to_txid
+            .transactions
+            .txid
             .iter()?
             .skip(first)
             .take(count)
@@ -67,13 +67,13 @@ impl Query {
             return Err(Error::OutOfRange("Block height out of range".into()));
         }
 
-        let first_txindex = indexer.vecs.tx.height_to_first_txindex.read_once(height)?;
+        let first_txindex = indexer.vecs.transactions.first_txindex.read_once(height)?;
         let next_first_txindex = indexer
             .vecs
-            .tx
-            .height_to_first_txindex
+            .transactions
+            .first_txindex
             .read_once(height.incremented())
-            .unwrap_or_else(|_| TxIndex::from(indexer.vecs.tx.txindex_to_txid.len()));
+            .unwrap_or_else(|_| TxIndex::from(indexer.vecs.transactions.txid.len()));
 
         let first: usize = first_txindex.into();
         let next: usize = next_first_txindex.into();
@@ -104,13 +104,13 @@ impl Query {
             return Err(Error::OutOfRange("Block height out of range".into()));
         }
 
-        let first_txindex = indexer.vecs.tx.height_to_first_txindex.read_once(height)?;
+        let first_txindex = indexer.vecs.transactions.first_txindex.read_once(height)?;
         let next_first_txindex = indexer
             .vecs
-            .tx
-            .height_to_first_txindex
+            .transactions
+            .first_txindex
             .read_once(height.incremented())
-            .unwrap_or_else(|_| TxIndex::from(indexer.vecs.tx.txindex_to_txid.len()));
+            .unwrap_or_else(|_| TxIndex::from(indexer.vecs.transactions.txid.len()));
 
         let first: usize = first_txindex.into();
         let next: usize = next_first_txindex.into();
@@ -121,7 +121,7 @@ impl Query {
         }
 
         let txindex = TxIndex::from(first + index);
-        let txid = indexer.vecs.tx.txindex_to_txid.iter()?.get_unwrap(txindex);
+        let txid = indexer.vecs.transactions.txid.iter()?.get_unwrap(txindex);
 
         Ok(txid)
     }