computer: blk metadata fixes

crates/brk_parser/Cargo.toml

@@ -20,6 +20,3 @@ crossbeam = { version = "0.8.4", features = ["crossbeam-channel"] }
 derive_deref = { workspace = true }
 parking_lot = { workspace = true }
 rayon = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-zerocopy = { workspace = true }

crates/brk_parser/examples/main.rs

@@ -26,7 +26,7 @@ fn main() -> Result<()> {
     let mut diff = BTreeMap::new();
     parser.parse(start, end).iter().for_each(|block| {
         println!("{}: {}", block.height(), block.hash());
-        let new_blk_index = block.position().blk_index();
+        let new_blk_index = block.metadata().blk_index();
         if new_blk_index < blk_index {
             diff.insert(blk_index - new_blk_index, block.height());
         }

crates/brk_parser/src/any_block.rs

@@ -1,7 +1,7 @@
 use bitcoin::{Transaction, VarInt, block::Header, consensus::Decodable, io::Cursor};
 use bitcoincore_rpc::RpcApi;
 use brk_error::Result;
-use brk_structs::{BlkPosition, Block, Height, ParsedBlock};
+use brk_structs::{BlkMetadata, Block, Height, ParsedBlock};
 
 use crate::{XORBytes, XORIndex};
 
@@ -14,7 +14,7 @@ pub enum AnyBlock {
 impl AnyBlock {
     pub fn decode(
         self,
-        position: BlkPosition,
+        metadata: BlkMetadata,
         rpc: &'static bitcoincore_rpc::Client,
         mut xor_i: XORIndex,
         xor_bytes: XORBytes,
@@ -55,17 +55,19 @@ impl AnyBlock {
         }
 
         let mut txdata = Vec::with_capacity(tx_count as usize);
-        let mut tx_positions = Vec::with_capacity(tx_count as usize);
+        let mut tx_metadata = Vec::with_capacity(tx_count as usize);
         for _ in 0..tx_count {
-            let tx_position = BlkPosition::new(position.blk_index(), cursor.position() as u32);
-            tx_positions.push(tx_position);
+            let offset = cursor.position() as u32;
+            let position = metadata.position() + offset;
             let tx = Transaction::consensus_decode(&mut cursor)?;
             txdata.push(tx);
+            let len = cursor.position() as u32 - offset;
+            tx_metadata.push(BlkMetadata::new(position, len));
         }
 
         let block = bitcoin::Block { header, txdata };
         let block = Block::from((height, hash, block));
-        let block = ParsedBlock::from((block, position, tx_positions));
+        let block = ParsedBlock::from((block, metadata, tx_metadata));
 
         Ok(Self::Decoded(block))
     }

crates/brk_parser/src/lib.rs

@@ -15,7 +15,7 @@ use bitcoin::{block::Header, consensus::Decodable};
 use bitcoincore_rpc::RpcApi;
 use blk_index_to_blk_path::*;
 use brk_error::Result;
-use brk_structs::{BlkPosition, Block, Height, ParsedBlock};
+use brk_structs::{BlkMetadata, BlkPosition, Block, Height, ParsedBlock};
 use crossbeam::channel::{Receiver, bounded};
 use parking_lot::{RwLock, RwLockReadGuard};
 use rayon::prelude::*;
@@ -123,8 +123,6 @@ impl Parser {
                             }
                         }
 
-                        let position = BlkPosition::new(blk_index, i as u32);
-
                         let len = u32::from_le_bytes(
                             xor_i
                                 .bytes(&mut blk_bytes[i..(i + 4)], xor_bytes)
@@ -133,10 +131,13 @@ impl Parser {
                         ) as usize;
                         i += 4;
 
+                        let position = BlkPosition::new(blk_index, i as u32);
+                        let metadata = BlkMetadata::new(position, len as u32);
+
                         let block_bytes = (blk_bytes[i..(i + len)]).to_vec();
 
                         if send_bytes
-                            .send((position, AnyBlock::Raw(block_bytes), xor_i))
+                            .send((metadata, AnyBlock::Raw(block_bytes), xor_i))
                             .is_err()
                         {
                             return ControlFlow::Break(());
@@ -156,13 +157,13 @@ impl Parser {
 
             let mut bulk = vec![];
 
-            let drain_and_send = |bulk: &mut Vec<(BlkPosition, AnyBlock, XORIndex)>| {
+            let drain_and_send = |bulk: &mut Vec<(BlkMetadata, AnyBlock, XORIndex)>| {
                 // Using a vec and sending after to not end up with stuck threads in par iter
                 mem::take(bulk)
                     .into_par_iter()
-                    .try_for_each(|(position, any_block, xor_i)| {
+                    .try_for_each(|(metdata, any_block, xor_i)| {
                         if let Ok(AnyBlock::Decoded(block)) =
-                            any_block.decode(position, rpc, xor_i, xor_bytes, start, end)
+                            any_block.decode(metdata, rpc, xor_i, xor_bytes, start, end)
                             && send_block.send(block).is_err()
                         {
                             return ControlFlow::Break(());