core: init

crates/brk_indexer/Cargo.toml

@@ -7,19 +7,16 @@ license = { workspace = true }
 
 [dependencies]
 bitcoin = { workspace = true }
+bitcoincore-rpc = { workspace = true }
+brk_core = { workspace = true }
 brk_parser = { workspace = true }
 brk_logger = { workspace = true }
 byteview = { workspace = true }
 color-eyre = { workspace = true }
-derive_deref = { workspace = true }
 fjall = { workspace = true }
 hodor = { workspace = true }
-jiff = { workspace = true }
 log = { workspace = true }
-rapidhash = "1.4.0"
 rayon = { workspace = true }
 rlimit = { version = "0.10.2" }
-serde = { workspace = true }
-serde_bytes = { workspace = true }
 storable_vec = { workspace = true }
 zerocopy = { workspace = true }

crates/brk_indexer/src/lib.rs

@@ -6,6 +6,10 @@ use std::{
     time::Duration,
 };
 
+use brk_core::{
+    AddressHash, Addressbytes, Addressindex, Addresstype, BlockHash, BlockHashPrefix, Height, Sats, Timestamp, Txid,
+    TxidPrefix, Txindex, Txinindex, Txoutindex, Vin, Vout,
+};
 pub use brk_parser::*;
 
 use bitcoin::{Transaction, TxIn, TxOut};
@@ -48,8 +52,6 @@ impl<const MODE: u8> Indexer<MODE> {
 
 impl Indexer<CACHED_GETS> {
     pub fn index(&mut self, parser: &Parser, rpc: &'static rpc::Client, exit: &Exit) -> color_eyre::Result<()> {
-        info!("Started indexing...");
-
         let check_collisions = true;
 
         let starting_indexes = Indexes::try_from((&mut self.vecs, &self.stores, rpc)).unwrap_or_else(|_| {
@@ -80,7 +82,13 @@ impl Indexer<CACHED_GETS> {
 
         let mut idxs = starting_indexes;
 
-        parser.parse(Some(idxs.height), None)
+        if idxs.height >= Height::try_from(rpc)? {
+            return Ok(());
+        }
+
+        info!("Started indexing...");
+
+        parser.parse(Some(idxs.height), Some(400_000_u32.into()))
             .iter()
             .try_for_each(|(height, block, blockhash)| -> color_eyre::Result<()> {
                 info!("Indexing block {height}...");
@@ -256,7 +264,7 @@ impl Indexer<CACHED_GETS> {
                                         Txindex,
                                         Vout,
                                         Addresstype,
-                                        color_eyre::Result<Addressbytes>,
+                                        brk_core::Result<Addressbytes>,
                                         Option<Addressindex>,
                                         &Transaction,
                                     ),
@@ -621,7 +629,6 @@ impl Indexer<CACHED_GETS> {
             })?;
 
         export(stores, vecs, idxs.height)?;
-
         sleep(Duration::from_millis(100));
 
         Ok(())

crates/brk_indexer/src/main.rs

@@ -34,7 +34,7 @@ fn main() -> color_eyre::Result<()> {
 
         indexer.index(&parser, rpc, &exit)?;
 
-        dbg!(i.elapsed());
+        info!("Took: {:?}", i.elapsed());
 
         info!("Waiting for a new block...");
 

crates/brk_indexer/src/storage/fjalls/base.rs

@@ -4,7 +4,7 @@ use std::{
     path::Path,
 };
 
-use brk_parser::Height;
+use brk_core::Height;
 use byteview::ByteView;
 use fjall::{
     PartitionCreateOptions, PersistMode, ReadTransaction, Result, TransactionalKeyspace, TransactionalPartitionHandle,

crates/brk_indexer/src/storage/fjalls/mod.rs

@@ -1,10 +1,9 @@
 use std::{path::Path, thread};
 
-use storable_vec::{Value, Version, CACHED_GETS};
+use brk_core::{AddressHash, Addressbytes, Addressindex, Addresstype, BlockHashPrefix, Height, TxidPrefix, Txindex};
+use storable_vec::{CACHED_GETS, Value, Version};
 
-use crate::{
-    AddressHash, Addressbytes, Addressindex, Addresstype, BlockHashPrefix, Height, Indexes, TxidPrefix, Txindex,
-};
+use crate::Indexes;
 
 mod base;
 mod meta;

crates/brk_indexer/src/storage/storable_vecs/base.rs

@@ -39,7 +39,7 @@ where
         self.vec.truncate_if_needed(index)
     }
 
-    pub fn height(&self) -> brk_parser::Result<Height> {
+    pub fn height(&self) -> brk_core::Result<Height> {
         Height::try_from(self.path_height().as_path())
     }
     fn path_height(&self) -> PathBuf {
@@ -71,7 +71,7 @@ impl<I, T, const MODE: u8> DerefMut for StorableVec<I, T, MODE> {
 }
 
 pub trait AnyStorableVec: Send + Sync {
-    fn height(&self) -> brk_parser::Result<Height>;
+    fn height(&self) -> brk_core::Result<Height>;
     fn flush(&mut self, height: Height) -> io::Result<()>;
 }
 
@@ -80,7 +80,7 @@ where
     I: StoredIndex,
     T: StoredType,
 {
-    fn height(&self) -> brk_parser::Result<Height> {
+    fn height(&self) -> brk_core::Result<Height> {
         self.height()
     }
 

crates/brk_indexer/src/storage/storable_vecs/mod.rs

@@ -1,19 +1,15 @@
 use std::{fs, io, path::Path};
 
-use brk_parser::Height;
+use brk_core::{
+    Addressbytes, Addressindex, Addresstype, Addresstypeindex, BlockHash, Emptyindex, Height, LockTime, Multisigindex,
+    Opreturnindex, P2PK33AddressBytes, P2PK33index, P2PK65AddressBytes, P2PK65index, P2PKHAddressBytes, P2PKHindex,
+    P2SHAddressBytes, P2SHindex, P2TRAddressBytes, P2TRindex, P2WPKHAddressBytes, P2WPKHindex, P2WSHAddressBytes,
+    P2WSHindex, Pushonlyindex, Sats, Timestamp, TxVersion, Txid, Txindex, Txinindex, Txoutindex, Unknownindex, Weight,
+};
 use rayon::prelude::*;
 use storable_vec::{AnyJsonStorableVec, CACHED_GETS, Version};
 
-use crate::{
-    Indexes,
-    structs::{
-        Addressbytes, Addressindex, Addresstype, Addresstypeindex, BlockHash, Emptyindex, LockTime, Multisigindex,
-        Opreturnindex, P2PK33AddressBytes, P2PK33index, P2PK65AddressBytes, P2PK65index, P2PKHAddressBytes, P2PKHindex,
-        P2SHAddressBytes, P2SHindex, P2TRAddressBytes, P2TRindex, P2WPKHAddressBytes, P2WPKHindex, P2WSHAddressBytes,
-        P2WSHindex, Pushonlyindex, Sats, Timestamp, TxVersion, Txid, Txindex, Txinindex, Txoutindex, Unknownindex,
-        Weight,
-    },
-};
+use crate::Indexes;
 
 mod base;
 

crates/brk_indexer/src/structs/addressbytes.rs

@@ -1,196 +0,0 @@
-use brk_parser::bitcoin::ScriptBuf;
-use color_eyre::eyre::eyre;
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use super::Addresstype;
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Addressbytes {
-    P2PK65(P2PK65AddressBytes),
-    P2PK33(P2PK33AddressBytes),
-    P2PKH(P2PKHAddressBytes),
-    P2SH(P2SHAddressBytes),
-    P2WPKH(P2WPKHAddressBytes),
-    P2WSH(P2WSHAddressBytes),
-    P2TR(P2TRAddressBytes),
-}
-
-impl Addressbytes {
-    pub fn as_slice(&self) -> &[u8] {
-        match self {
-            Addressbytes::P2PK65(bytes) => &bytes[..],
-            Addressbytes::P2PK33(bytes) => &bytes[..],
-            Addressbytes::P2PKH(bytes) => &bytes[..],
-            Addressbytes::P2SH(bytes) => &bytes[..],
-            Addressbytes::P2WPKH(bytes) => &bytes[..],
-            Addressbytes::P2WSH(bytes) => &bytes[..],
-            Addressbytes::P2TR(bytes) => &bytes[..],
-        }
-    }
-}
-
-impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
-    type Error = color_eyre::Report;
-    fn try_from(tuple: (&ScriptBuf, Addresstype)) -> Result<Self, Self::Error> {
-        let (script, addresstype) = tuple;
-
-        match addresstype {
-            Addresstype::P2PK65 => {
-                let bytes = script.as_bytes();
-                let bytes = match bytes.len() {
-                    67 => &bytes[1..66],
-                    _ => {
-                        dbg!(bytes);
-                        return Err(eyre!("Wrong len"));
-                    }
-                };
-                Ok(Self::P2PK65(P2PK65AddressBytes(U8x65::from(bytes))))
-            }
-            Addresstype::P2PK33 => {
-                let bytes = script.as_bytes();
-                let bytes = match bytes.len() {
-                    35 => &bytes[1..34],
-                    _ => {
-                        dbg!(bytes);
-                        return Err(eyre!("Wrong len"));
-                    }
-                };
-                Ok(Self::P2PK33(P2PK33AddressBytes(U8x33::from(bytes))))
-            }
-            Addresstype::P2PKH => {
-                let bytes = &script.as_bytes()[3..23];
-                Ok(Self::P2PKH(P2PKHAddressBytes(U8x20::from(bytes))))
-            }
-            Addresstype::P2SH => {
-                let bytes = &script.as_bytes()[2..22];
-                Ok(Self::P2SH(P2SHAddressBytes(U8x20::from(bytes))))
-            }
-            Addresstype::P2WPKH => {
-                let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2WPKH(P2WPKHAddressBytes(U8x20::from(bytes))))
-            }
-            Addresstype::P2WSH => {
-                let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2WSH(P2WSHAddressBytes(U8x32::from(bytes))))
-            }
-            Addresstype::P2TR => {
-                let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2TR(P2TRAddressBytes(U8x32::from(bytes))))
-            }
-            Addresstype::Multisig => Err(eyre!("multisig address type")),
-            Addresstype::PushOnly => Err(eyre!("push_only address type")),
-            Addresstype::Unknown => Err(eyre!("unknown address type")),
-            Addresstype::Empty => Err(eyre!("empty address type")),
-            Addresstype::OpReturn => Err(eyre!("op_return address type")),
-        }
-    }
-}
-
-impl From<P2PK65AddressBytes> for Addressbytes {
-    fn from(value: P2PK65AddressBytes) -> Self {
-        Self::P2PK65(value)
-    }
-}
-impl From<P2PK33AddressBytes> for Addressbytes {
-    fn from(value: P2PK33AddressBytes) -> Self {
-        Self::P2PK33(value)
-    }
-}
-impl From<P2PKHAddressBytes> for Addressbytes {
-    fn from(value: P2PKHAddressBytes) -> Self {
-        Self::P2PKH(value)
-    }
-}
-impl From<P2SHAddressBytes> for Addressbytes {
-    fn from(value: P2SHAddressBytes) -> Self {
-        Self::P2SH(value)
-    }
-}
-impl From<P2WPKHAddressBytes> for Addressbytes {
-    fn from(value: P2WPKHAddressBytes) -> Self {
-        Self::P2WPKH(value)
-    }
-}
-impl From<P2WSHAddressBytes> for Addressbytes {
-    fn from(value: P2WSHAddressBytes) -> Self {
-        Self::P2WSH(value)
-    }
-}
-impl From<P2TRAddressBytes> for Addressbytes {
-    fn from(value: P2TRAddressBytes) -> Self {
-        Self::P2TR(value)
-    }
-}
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2PK65AddressBytes(U8x65);
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2PK33AddressBytes(U8x33);
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2PKHAddressBytes(U8x20);
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2SHAddressBytes(U8x20);
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2WPKHAddressBytes(U8x20);
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2WSHAddressBytes(U8x32);
-
-#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct P2TRAddressBytes(U8x32);
-
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct U8x20([u8; 20]);
-impl From<&[u8]> for U8x20 {
-    fn from(slice: &[u8]) -> Self {
-        let mut arr = [0; 20];
-        arr.copy_from_slice(slice);
-        Self(arr)
-    }
-}
-
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct U8x32([u8; 32]);
-impl From<&[u8]> for U8x32 {
-    fn from(slice: &[u8]) -> Self {
-        let mut arr = [0; 32];
-        arr.copy_from_slice(slice);
-        Self(arr)
-    }
-}
-
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct U8x33(#[serde(with = "serde_bytes")] [u8; 33]);
-impl From<&[u8]> for U8x33 {
-    fn from(slice: &[u8]) -> Self {
-        let mut arr = [0; 33];
-        arr.copy_from_slice(slice);
-        Self(arr)
-    }
-}
-
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct U8x64(#[serde(with = "serde_bytes")] [u8; 64]);
-impl From<&[u8]> for U8x64 {
-    fn from(slice: &[u8]) -> Self {
-        let mut arr = [0; 64];
-        arr.copy_from_slice(slice);
-        Self(arr)
-    }
-}
-
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct U8x65(#[serde(with = "serde_bytes")] [u8; 65]);
-impl From<&[u8]> for U8x65 {
-    fn from(slice: &[u8]) -> Self {
-        let mut arr = [0; 65];
-        arr.copy_from_slice(slice);
-        Self(arr)
-    }
-}

crates/brk_indexer/src/structs/addressindex.rs

@@ -1,95 +0,0 @@
-use std::ops::Add;
-
-use byteview::ByteView;
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Addressindex(u32);
-
-impl Addressindex {
-    pub const BYTES: usize = size_of::<Self>();
-
-    pub fn decremented(self) -> Self {
-        Self(*self - 1)
-    }
-
-    pub fn increment(&mut self) {
-        self.0 += 1;
-    }
-
-    pub fn incremented(self) -> Self {
-        Self(*self + 1)
-    }
-}
-
-impl From<u32> for Addressindex {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<u64> for Addressindex {
-    fn from(value: u64) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Addressindex> for u64 {
-    fn from(value: Addressindex) -> Self {
-        value.0 as u64
-    }
-}
-
-impl From<usize> for Addressindex {
-    fn from(value: usize) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Addressindex> for usize {
-    fn from(value: Addressindex) -> Self {
-        value.0 as usize
-    }
-}
-
-impl TryFrom<ByteView> for Addressindex {
-    type Error = storable_vec::Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<Addressindex> for ByteView {
-    fn from(value: Addressindex) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-
-impl Add<usize> for Addressindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(self.0 + rhs as u32)
-    }
-}
-
-impl Add<Addressindex> for Addressindex {
-    type Output = Self;
-    fn add(self, rhs: Addressindex) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}

crates/brk_indexer/src/structs/addresstype.rs

@@ -1,59 +0,0 @@
-use brk_parser::bitcoin::ScriptBuf;
-use serde::Serialize;
-use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
-
-#[derive(
-    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, TryFromBytes, Immutable, IntoBytes, KnownLayout, Serialize,
-)]
-#[repr(u8)]
-pub enum Addresstype {
-    P2PK65,
-    P2PK33,
-    P2PKH,
-    P2SH,
-    P2WPKH,
-    P2WSH,
-    P2TR,
-    Multisig = 251,
-    PushOnly = 252,
-    OpReturn = 253,
-    Empty = 254,
-    Unknown = 255,
-}
-
-impl From<&ScriptBuf> for Addresstype {
-    fn from(script: &ScriptBuf) -> Self {
-        if script.is_p2pk() {
-            let bytes = script.as_bytes();
-
-            match bytes.len() {
-                67 => Self::P2PK65,
-                35 => Self::P2PK33,
-                _ => {
-                    dbg!(bytes);
-                    unreachable!()
-                }
-            }
-        } else if script.is_p2pkh() {
-            Self::P2PKH
-        } else if script.is_p2sh() {
-            Self::P2SH
-        } else if script.is_p2wpkh() {
-            Self::P2WPKH
-        } else if script.is_p2wsh() {
-            Self::P2WSH
-        } else if script.is_p2tr() {
-            Self::P2TR
-        } else if script.is_empty() {
-            Self::Empty
-        } else if script.is_op_return() {
-            Self::OpReturn
-        } else if script.is_push_only() {
-            Self::PushOnly
-        } else if script.is_multisig() {
-            Self::Multisig
-        } else {
-            Self::Unknown
-        }
-    }
-}

crates/brk_indexer/src/structs/addresstypeindex.rs

@@ -1,566 +0,0 @@
-use std::ops::Add;
-
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Addresstypeindex(u32);
-
-impl Addresstypeindex {
-    pub fn decremented(self) -> Self {
-        Self(*self - 1)
-    }
-
-    pub fn increment(&mut self) {
-        self.0 += 1;
-    }
-
-    pub fn incremented(self) -> Self {
-        Self(*self + 1)
-    }
-
-    pub fn copy_then_increment(&mut self) -> Self {
-        let i = *self;
-        self.increment();
-        i
-    }
-}
-
-impl From<u32> for Addresstypeindex {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<u64> for Addresstypeindex {
-    fn from(value: u64) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Addresstypeindex> for u64 {
-    fn from(value: Addresstypeindex) -> Self {
-        value.0 as u64
-    }
-}
-
-impl From<usize> for Addresstypeindex {
-    fn from(value: usize) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Addresstypeindex> for usize {
-    fn from(value: Addresstypeindex) -> Self {
-        value.0 as usize
-    }
-}
-
-impl Add<usize> for Addresstypeindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(self.0 + rhs as u32)
-    }
-}
-
-impl Add<Addresstypeindex> for Addresstypeindex {
-    type Output = Self;
-    fn add(self, rhs: Addresstypeindex) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Emptyindex(Addresstypeindex);
-impl From<Addresstypeindex> for Emptyindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Emptyindex> for usize {
-    fn from(value: Emptyindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Emptyindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Emptyindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Multisigindex(Addresstypeindex);
-impl From<Addresstypeindex> for Multisigindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Multisigindex> for usize {
-    fn from(value: Multisigindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Multisigindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Multisigindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Opreturnindex(Addresstypeindex);
-impl From<Addresstypeindex> for Opreturnindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Opreturnindex> for usize {
-    fn from(value: Opreturnindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Opreturnindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Opreturnindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Pushonlyindex(Addresstypeindex);
-impl From<Addresstypeindex> for Pushonlyindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Pushonlyindex> for usize {
-    fn from(value: Pushonlyindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Pushonlyindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Pushonlyindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Unknownindex(Addresstypeindex);
-impl From<Addresstypeindex> for Unknownindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Unknownindex> for usize {
-    fn from(value: Unknownindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Unknownindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Unknownindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2PK33index(Addresstypeindex);
-impl From<Addresstypeindex> for P2PK33index {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2PK33index> for usize {
-    fn from(value: P2PK33index) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2PK33index {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2PK33index {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2PK65index(Addresstypeindex);
-impl From<Addresstypeindex> for P2PK65index {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2PK65index> for usize {
-    fn from(value: P2PK65index) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2PK65index {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2PK65index {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2PKHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2PKHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2PKHindex> for usize {
-    fn from(value: P2PKHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2PKHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2PKHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2SHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2SHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2SHindex> for usize {
-    fn from(value: P2SHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2SHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2SHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2TRindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2TRindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2TRindex> for usize {
-    fn from(value: P2TRindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2TRindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2TRindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2WPKHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2WPKHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2WPKHindex> for usize {
-    fn from(value: P2WPKHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2WPKHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2WPKHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2WSHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2WSHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2WSHindex> for usize {
-    fn from(value: P2WSHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2WSHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2WSHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}

crates/brk_indexer/src/structs/blockhash.rs

@@ -1,31 +0,0 @@
-use std::mem;
-
-use brk_parser::{
-    Height,
-    rpc::{Client, RpcApi},
-};
-use derive_deref::Deref;
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct BlockHash([u8; 32]);
-
-impl From<bitcoin::BlockHash> for BlockHash {
-    fn from(value: bitcoin::BlockHash) -> Self {
-        unsafe { mem::transmute(value) }
-    }
-}
-
-impl From<BlockHash> for bitcoin::BlockHash {
-    fn from(value: BlockHash) -> Self {
-        unsafe { mem::transmute(value) }
-    }
-}
-
-impl TryFrom<(&Client, Height)> for BlockHash {
-    type Error = brk_parser::rpc::Error;
-    fn try_from((rpc, height): (&Client, Height)) -> Result<Self, Self::Error> {
-        Ok(Self::from(rpc.get_block_hash(u64::from(height))?))
-    }
-}

crates/brk_indexer/src/structs/compressed.rs

@@ -1,100 +0,0 @@
-use std::hash::Hasher;
-
-use byteview::ByteView;
-use derive_deref::Deref;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use super::{Addressbytes, Addresstype, BlockHash, Txid};
-
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout)]
-pub struct AddressHash([u8; 8]);
-impl From<(&Addressbytes, Addresstype)> for AddressHash {
-    fn from((addressbytes, addresstype): (&Addressbytes, Addresstype)) -> Self {
-        let mut hasher = rapidhash::RapidHasher::default();
-        hasher.write(addressbytes.as_slice());
-        let mut slice = hasher.finish().to_le_bytes();
-        slice[0] = slice[0].wrapping_add(addresstype as u8);
-        Self(slice)
-    }
-}
-impl From<[u8; 8]> for AddressHash {
-    fn from(value: [u8; 8]) -> Self {
-        Self(value)
-    }
-}
-impl TryFrom<ByteView> for AddressHash {
-    type Error = storable_vec::Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<&AddressHash> for ByteView {
-    fn from(value: &AddressHash) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-impl From<AddressHash> for ByteView {
-    fn from(value: AddressHash) -> Self {
-        Self::from(&value)
-    }
-}
-
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout)]
-pub struct BlockHashPrefix([u8; 8]);
-impl From<&BlockHash> for BlockHashPrefix {
-    fn from(value: &BlockHash) -> Self {
-        Self(copy_first_8bytes(&value[..]).unwrap())
-    }
-}
-impl TryFrom<ByteView> for BlockHashPrefix {
-    type Error = storable_vec::Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<&BlockHashPrefix> for ByteView {
-    fn from(value: &BlockHashPrefix) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-impl From<BlockHashPrefix> for ByteView {
-    fn from(value: BlockHashPrefix) -> Self {
-        Self::from(&value)
-    }
-}
-
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout)]
-pub struct TxidPrefix([u8; 8]);
-impl From<&Txid> for TxidPrefix {
-    fn from(value: &Txid) -> Self {
-        Self(copy_first_8bytes(&value[..]).unwrap())
-    }
-}
-impl TryFrom<ByteView> for TxidPrefix {
-    type Error = storable_vec::Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<&TxidPrefix> for ByteView {
-    fn from(value: &TxidPrefix) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-impl From<TxidPrefix> for ByteView {
-    fn from(value: TxidPrefix) -> Self {
-        Self::from(&value)
-    }
-}
-
-fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8], ()> {
-    let mut buf: [u8; 8] = [0; 8];
-    let buf_len = buf.len();
-    if slice.len() < buf_len {
-        return Err(());
-    }
-    slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
-        buf[i] = *r;
-    });
-    Ok(buf)
-}

crates/brk_indexer/src/structs/indexes.rs

@@ -1,15 +1,14 @@
+use bitcoincore_rpc::Client;
+use brk_core::{
+    Addressindex, BlockHash, Emptyindex, Height, Multisigindex, Opreturnindex, P2PK33index, P2PK65index, P2PKHindex,
+    P2SHindex, P2TRindex, P2WPKHindex, P2WSHindex, Pushonlyindex, Txindex, Txinindex, Txoutindex, Unknownindex,
+};
 use brk_parser::NUMBER_OF_UNSAFE_BLOCKS;
-use brk_parser::{Height, rpc::Client};
 use color_eyre::eyre::ContextCompat;
 use storable_vec::CACHED_GETS;
 
 use crate::storage::{Fjalls, StorableVecs};
 
-use super::{
-    Addressindex, BlockHash, Emptyindex, Multisigindex, Opreturnindex, P2PK33index, P2PK65index, P2PKHindex, P2SHindex,
-    P2TRindex, P2WPKHindex, P2WSHindex, Pushonlyindex, Txindex, Txinindex, Txoutindex, Unknownindex,
-};
-
 #[derive(Debug, Default)]
 pub struct Indexes {
     pub addressindex: Addressindex,
@@ -79,18 +78,28 @@ impl TryFrom<(&mut StorableVecs<CACHED_GETS>, &Fjalls, &Client)> for Indexes {
         // Height at which we wanna start: min last saved + 1 or 0
         let starting_height = vecs.starting_height().min(trees.starting_height());
 
-        // But we also need to check the chain and start earlier in case of a reorg
-        let height = (starting_height
+        let range = starting_height
             .checked_sub(NUMBER_OF_UNSAFE_BLOCKS as u32)
-            .unwrap_or_default()..*starting_height) // ..= because of last saved + 1
+            .unwrap_or_default()..*starting_height;
+
+        // But we also need to check the chain and start earlier in case of a reorg
+        let height = range // ..= because of last saved + 1
             .map(Height::from)
             .find(|height| {
-                let rpc_blockhash = BlockHash::try_from((rpc, *height)).unwrap();
-                let saved_blockhash = vecs.height_to_blockhash.get(*height).unwrap().unwrap();
-                &rpc_blockhash != saved_blockhash.as_ref()
+                let rpc_blockhash = BlockHash::try_from((rpc, *height))
+                    .inspect_err(|e| {
+                        dbg!(e, height);
+                    })
+                    .unwrap();
+
+                vecs.height_to_blockhash.get(*height).map_or(true, |opt| {
+                    opt.is_none_or(|saved_blockhash| &rpc_blockhash != saved_blockhash.as_ref())
+                })
             })
             .unwrap_or(starting_height);
 
+        // let height = 885000_u32.into();
+
         Ok(Self {
             addressindex: *vecs.height_to_first_addressindex.get(height)?.context("")?,
             emptyindex: *vecs.height_to_first_emptyindex.get(height)?.context("")?,

crates/brk_indexer/src/structs/locktime.rs

@@ -1,30 +0,0 @@
-use brk_parser::Height;
-use serde::Serialize;
-use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
-
-use super::Timestamp;
-
-#[derive(Debug, Immutable, Clone, Copy, IntoBytes, KnownLayout, TryFromBytes, Serialize)]
-#[repr(C)]
-pub enum LockTime {
-    Height(Height),
-    Timestamp(Timestamp),
-}
-
-impl From<bitcoin::absolute::LockTime> for LockTime {
-    fn from(value: bitcoin::absolute::LockTime) -> Self {
-        match value {
-            bitcoin::absolute::LockTime::Blocks(h) => LockTime::Height(h.into()),
-            bitcoin::absolute::LockTime::Seconds(t) => LockTime::Timestamp(t.into()),
-        }
-    }
-}
-
-impl From<LockTime> for bitcoin::absolute::LockTime {
-    fn from(value: LockTime) -> Self {
-        match value {
-            LockTime::Height(h) => bitcoin::absolute::LockTime::Blocks(h.into()),
-            LockTime::Timestamp(t) => bitcoin::absolute::LockTime::Seconds(t.into()),
-        }
-    }
-}

crates/brk_indexer/src/structs/mod.rs

@@ -1,37 +1,3 @@
-mod addressbytes;
-mod addressindex;
-mod addresstype;
-mod addresstypeindex;
-mod blockhash;
-mod compressed;
 mod indexes;
-mod locktime;
-mod sats;
-mod timestamp;
-mod txid;
-mod txindex;
-mod txinindex;
-mod txoutindex;
-mod txversion;
-mod vin;
-mod vout;
-mod weight;
 
-pub use addressbytes::*;
-pub use addressindex::*;
-pub use addresstype::*;
-pub use addresstypeindex::*;
-pub use blockhash::*;
-pub use compressed::*;
 pub use indexes::*;
-pub use locktime::*;
-pub use sats::*;
-pub use timestamp::*;
-pub use txid::*;
-pub use txindex::*;
-pub use txinindex::*;
-pub use txoutindex::*;
-pub use txversion::*;
-pub use vin::*;
-pub use vout::*;
-pub use weight::*;

crates/brk_indexer/src/structs/sats.rs

@@ -1,107 +0,0 @@
-use std::{
-    iter::Sum,
-    ops::{Add, AddAssign, Mul, Sub, SubAssign},
-};
-
-use brk_parser::{Height, bitcoin::Amount};
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Sats(u64);
-
-impl Sats {
-    pub const ZERO: Self = Self(0);
-
-    pub fn is_zero(&self) -> bool {
-        *self == Self::ZERO
-    }
-}
-
-impl Add for Sats {
-    type Output = Sats;
-    fn add(self, rhs: Sats) -> Self::Output {
-        Sats::from(*self + *rhs)
-    }
-}
-
-impl AddAssign for Sats {
-    fn add_assign(&mut self, rhs: Self) {
-        *self = *self + rhs;
-    }
-}
-
-impl Sub for Sats {
-    type Output = Sats;
-    fn sub(self, rhs: Sats) -> Self::Output {
-        Sats::from(*self - *rhs)
-    }
-}
-
-impl SubAssign for Sats {
-    fn sub_assign(&mut self, rhs: Self) {
-        *self = *self - rhs;
-    }
-}
-
-impl Mul<Sats> for Sats {
-    type Output = Sats;
-    fn mul(self, rhs: Sats) -> Self::Output {
-        Sats::from(*self * *rhs)
-    }
-}
-
-impl Mul<u64> for Sats {
-    type Output = Sats;
-    fn mul(self, rhs: u64) -> Self::Output {
-        Sats::from(*self * rhs)
-    }
-}
-
-impl Mul<Height> for Sats {
-    type Output = Sats;
-    fn mul(self, rhs: Height) -> Self::Output {
-        Sats::from(*self * *rhs as u64)
-    }
-}
-
-impl Sum for Sats {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        let sats: u64 = iter.map(|sats| *sats).sum();
-        Sats::from(sats)
-    }
-}
-
-impl From<u64> for Sats {
-    fn from(value: u64) -> Self {
-        Self(value)
-    }
-}
-
-impl From<Amount> for Sats {
-    fn from(value: Amount) -> Self {
-        Self(value.to_sat())
-    }
-}
-impl From<Sats> for Amount {
-    fn from(value: Sats) -> Self {
-        Self::from_sat(value.0)
-    }
-}

crates/brk_indexer/src/structs/timestamp.rs

@@ -1,32 +0,0 @@
-use derive_deref::Deref;
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(
-    Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize,
-)]
-pub struct Timestamp(u32);
-
-impl From<u32> for Timestamp {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<Timestamp> for jiff::Timestamp {
-    fn from(value: Timestamp) -> Self {
-        jiff::Timestamp::from_second(*value as i64).unwrap()
-    }
-}
-
-impl From<bitcoin::locktime::absolute::Time> for Timestamp {
-    fn from(value: bitcoin::locktime::absolute::Time) -> Self {
-        Self(value.to_consensus_u32())
-    }
-}
-
-impl From<Timestamp> for bitcoin::locktime::absolute::Time {
-    fn from(value: Timestamp) -> Self {
-        bitcoin::locktime::absolute::Time::from_consensus(*value).unwrap()
-    }
-}

crates/brk_indexer/src/structs/txid.rs

@@ -1,20 +0,0 @@
-use std::mem;
-
-use derive_deref::Deref;
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct Txid([u8; 32]);
-
-impl From<bitcoin::Txid> for Txid {
-    fn from(value: bitcoin::Txid) -> Self {
-        unsafe { mem::transmute(value) }
-    }
-}
-
-impl From<Txid> for bitcoin::Txid {
-    fn from(value: Txid) -> Self {
-        unsafe { mem::transmute(value) }
-    }
-}

crates/brk_indexer/src/structs/txindex.rs

@@ -1,102 +0,0 @@
-use std::ops::{Add, AddAssign, Sub};
-
-use byteview::ByteView;
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Txindex(u32);
-
-impl Txindex {
-    pub fn incremented(self) -> Self {
-        Self(*self + 1)
-    }
-
-    pub fn decremented(self) -> Self {
-        Self(*self - 1)
-    }
-}
-
-impl Add<Txindex> for Txindex {
-    type Output = Self;
-    fn add(self, rhs: Txindex) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl Add<usize> for Txindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(self.0 + rhs as u32)
-    }
-}
-
-impl AddAssign<Txindex> for Txindex {
-    fn add_assign(&mut self, rhs: Txindex) {
-        self.0 += rhs.0
-    }
-}
-
-impl Sub<Txindex> for Txindex {
-    type Output = Txindex;
-    fn sub(self, rhs: Txindex) -> Self::Output {
-        Self::from(*self - *rhs)
-    }
-}
-
-impl From<u32> for Txindex {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<u64> for Txindex {
-    fn from(value: u64) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Txindex> for u64 {
-    fn from(value: Txindex) -> Self {
-        value.0 as u64
-    }
-}
-
-impl From<usize> for Txindex {
-    fn from(value: usize) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Txindex> for usize {
-    fn from(value: Txindex) -> Self {
-        value.0 as usize
-    }
-}
-
-impl TryFrom<ByteView> for Txindex {
-    type Error = storable_vec::Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<Txindex> for ByteView {
-    fn from(value: Txindex) -> Self {
-        Self::new(value.as_bytes())
-    }
-}

crates/brk_indexer/src/structs/txinindex.rs

@@ -1,101 +0,0 @@
-use std::ops::{Add, AddAssign, Sub};
-
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use super::Vin;
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Txinindex(u64);
-
-impl Txinindex {
-    pub fn incremented(self) -> Self {
-        Self(*self + 1)
-    }
-
-    pub fn decremented(self) -> Self {
-        Self(*self - 1)
-    }
-}
-
-impl Add<Txinindex> for Txinindex {
-    type Output = Self;
-    fn add(self, rhs: Txinindex) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl Add<Vin> for Txinindex {
-    type Output = Self;
-    fn add(self, rhs: Vin) -> Self::Output {
-        Self(self.0 + u64::from(rhs))
-    }
-}
-
-impl Add<usize> for Txinindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(self.0 + rhs as u64)
-    }
-}
-
-impl AddAssign<Txinindex> for Txinindex {
-    fn add_assign(&mut self, rhs: Txinindex) {
-        self.0 += rhs.0
-    }
-}
-
-impl Sub<Txinindex> for Txinindex {
-    type Output = Self;
-    fn sub(self, rhs: Txinindex) -> Self::Output {
-        Self(self.0 - rhs.0)
-    }
-}
-
-impl From<Txinindex> for u32 {
-    fn from(value: Txinindex) -> Self {
-        if value.0 > u32::MAX as u64 {
-            panic!()
-        }
-        value.0 as u32
-    }
-}
-
-impl From<u64> for Txinindex {
-    fn from(value: u64) -> Self {
-        Self(value)
-    }
-}
-impl From<Txinindex> for u64 {
-    fn from(value: Txinindex) -> Self {
-        value.0
-    }
-}
-
-impl From<usize> for Txinindex {
-    fn from(value: usize) -> Self {
-        Self(value as u64)
-    }
-}
-impl From<Txinindex> for usize {
-    fn from(value: Txinindex) -> Self {
-        value.0 as usize
-    }
-}

crates/brk_indexer/src/structs/txoutindex.rs

@@ -1,107 +0,0 @@
-use std::ops::{Add, AddAssign, Sub};
-
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use super::Vout;
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Txoutindex(u64);
-
-impl Txoutindex {
-    pub const COINBASE: Self = Self(u64::MAX);
-
-    pub fn incremented(self) -> Self {
-        Self(*self + 1)
-    }
-
-    pub fn decremented(self) -> Self {
-        Self(*self - 1)
-    }
-
-    pub fn is_coinbase(self) -> bool {
-        self == Self::COINBASE
-    }
-}
-
-impl Add<Txoutindex> for Txoutindex {
-    type Output = Self;
-    fn add(self, rhs: Txoutindex) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl Add<Vout> for Txoutindex {
-    type Output = Self;
-    fn add(self, rhs: Vout) -> Self::Output {
-        Self(self.0 + u64::from(rhs))
-    }
-}
-
-impl Add<usize> for Txoutindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(self.0 + rhs as u64)
-    }
-}
-
-impl AddAssign<Txoutindex> for Txoutindex {
-    fn add_assign(&mut self, rhs: Txoutindex) {
-        self.0 += rhs.0
-    }
-}
-
-impl Sub<Txoutindex> for Txoutindex {
-    type Output = Self;
-    fn sub(self, rhs: Txoutindex) -> Self::Output {
-        Self(self.0 - rhs.0)
-    }
-}
-
-impl From<Txoutindex> for u32 {
-    fn from(value: Txoutindex) -> Self {
-        if value.0 > u32::MAX as u64 {
-            panic!()
-        }
-        value.0 as u32
-    }
-}
-
-impl From<u64> for Txoutindex {
-    fn from(value: u64) -> Self {
-        Self(value)
-    }
-}
-impl From<Txoutindex> for u64 {
-    fn from(value: Txoutindex) -> Self {
-        value.0
-    }
-}
-
-impl From<usize> for Txoutindex {
-    fn from(value: usize) -> Self {
-        Self(value as u64)
-    }
-}
-impl From<Txoutindex> for usize {
-    fn from(value: Txoutindex) -> Self {
-        value.0 as usize
-    }
-}

crates/brk_indexer/src/structs/txversion.rs

@@ -1,18 +0,0 @@
-use derive_deref::Deref;
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct TxVersion(i32);
-
-impl From<bitcoin::transaction::Version> for TxVersion {
-    fn from(value: bitcoin::transaction::Version) -> Self {
-        Self(value.0)
-    }
-}
-
-impl From<TxVersion> for bitcoin::transaction::Version {
-    fn from(value: TxVersion) -> Self {
-        Self(value.0)
-    }
-}

crates/brk_indexer/src/structs/vin.rs

@@ -1,31 +0,0 @@
-use derive_deref::Deref;
-
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Vin(u32);
-
-impl Vin {
-    pub const ZERO: Self = Vin(0);
-    pub const ONE: Self = Vin(1);
-
-    pub fn is_zero(&self) -> bool {
-        *self == Self::ZERO
-    }
-}
-
-impl From<u32> for Vin {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<usize> for Vin {
-    fn from(value: usize) -> Self {
-        Self(value as u32)
-    }
-}
-
-impl From<Vin> for u64 {
-    fn from(value: Vin) -> Self {
-        value.0 as u64
-    }
-}

crates/brk_indexer/src/structs/vout.rs

@@ -1,30 +0,0 @@
-use derive_deref::Deref;
-
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Vout(u32);
-
-impl Vout {
-    const ZERO: Self = Vout(0);
-
-    pub fn is_zero(&self) -> bool {
-        *self == Self::ZERO
-    }
-}
-
-impl From<u32> for Vout {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<usize> for Vout {
-    fn from(value: usize) -> Self {
-        Self(value as u32)
-    }
-}
-
-impl From<Vout> for u64 {
-    fn from(value: Vout) -> Self {
-        value.0 as u64
-    }
-}

crates/brk_indexer/src/structs/weight.rs

@@ -1,18 +0,0 @@
-use derive_deref::Deref;
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct Weight(u64);
-
-impl From<bitcoin::Weight> for Weight {
-    fn from(value: bitcoin::Weight) -> Self {
-        Self(value.to_wu())
-    }
-}
-
-impl From<Weight> for bitcoin::Weight {
-    fn from(value: Weight) -> Self {
-        Self::from_wu(*value)
-    }
-}