global: renames + refactor + p2a support

crates/brk_core/src/structs/_addressindex.rs

@@ -21,9 +21,9 @@ use crate::Error;
     KnownLayout,
     Serialize,
 )]
-pub struct Addressindex(u32);
+pub struct AddressIndex(u32);
 
-impl Addressindex {
+impl AddressIndex {
     pub const BYTES: usize = size_of::<Self>();
 
     pub fn increment(&mut self) {
@@ -35,56 +35,56 @@ impl Addressindex {
     }
 }
 
-impl From<u32> for Addressindex {
+impl From<u32> for AddressIndex {
     fn from(value: u32) -> Self {
         Self(value)
     }
 }
 
-impl From<u64> for Addressindex {
+impl From<u64> for AddressIndex {
     fn from(value: u64) -> Self {
         Self(value as u32)
     }
 }
-impl From<Addressindex> for u64 {
-    fn from(value: Addressindex) -> Self {
+impl From<AddressIndex> for u64 {
+    fn from(value: AddressIndex) -> Self {
         value.0 as u64
     }
 }
 
-impl From<usize> for Addressindex {
+impl From<usize> for AddressIndex {
     fn from(value: usize) -> Self {
         Self(value as u32)
     }
 }
-impl From<Addressindex> for usize {
-    fn from(value: Addressindex) -> Self {
+impl From<AddressIndex> for usize {
+    fn from(value: AddressIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl TryFrom<ByteView> for Addressindex {
+impl TryFrom<ByteView> for AddressIndex {
     type Error = 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 {
+impl From<AddressIndex> for ByteView {
+    fn from(value: AddressIndex) -> Self {
         Self::new(value.as_bytes())
     }
 }
 
-impl Add<usize> for Addressindex {
+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 {
+impl Add<AddressIndex> for AddressIndex {
     type Output = Self;
-    fn add(self, rhs: Addressindex) -> Self::Output {
+    fn add(self, rhs: AddressIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }

crates/brk_core/src/structs/_addressindexoutputindex.rs

@@ -0,0 +1,28 @@
+use byteview::ByteView;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::Error;
+
+use super::{AddressIndex, Outputindex};
+
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Immutable, IntoBytes, KnownLayout, FromBytes,
+)]
+#[repr(C)]
+pub struct AddressIndexOutputIndex {
+    addressindex: AddressIndex,
+    _padding: u32,
+    outputindex: Outputindex,
+}
+
+impl TryFrom<ByteView> for AddressIndexOutputIndex {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<AddressIndexOutputIndex> for ByteView {
+    fn from(value: AddressIndexOutputIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/_addresstype.rs

@@ -0,0 +1,48 @@
+use serde::Serialize;
+use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+
+use super::OutputType;
+
+#[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,
+    P2A,
+}
+
+impl From<OutputType> for AddressType {
+    fn from(value: OutputType) -> Self {
+        match value {
+            OutputType::P2A => Self::P2A,
+            OutputType::P2PK33 => Self::P2PK33,
+            OutputType::P2PK65 => Self::P2PK65,
+            OutputType::P2PKH => Self::P2PKH,
+            OutputType::P2SH => Self::P2SH,
+            OutputType::P2TR => Self::P2TR,
+            OutputType::P2WPKH => Self::P2WPKH,
+            OutputType::P2WSH => Self::P2WSH,
+            OutputType::Empty | OutputType::OpReturn | OutputType::P2MS | OutputType::Unknown => {
+                unreachable!()
+            }
+        }
+    }
+}

crates/brk_core/src/structs/addressbytes.rs

@@ -12,40 +12,42 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::Error;
 
-use super::Addresstype;
+use super::OutputType;
 
 #[derive(Debug, PartialEq, Eq)]
-pub enum Addressbytes {
-    P2PK65(P2PK65AddressBytes),
-    P2PK33(P2PK33AddressBytes),
-    P2PKH(P2PKHAddressBytes),
-    P2SH(P2SHAddressBytes),
-    P2WPKH(P2WPKHAddressBytes),
-    P2WSH(P2WSHAddressBytes),
-    P2TR(P2TRAddressBytes),
+pub enum AddressBytes {
+    P2PK65(P2PK65Bytes),
+    P2PK33(P2PK33Bytes),
+    P2PKH(P2PKHBytes),
+    P2SH(P2SHBytes),
+    P2WPKH(P2WPKHBytes),
+    P2WSH(P2WSHBytes),
+    P2TR(P2TRBytes),
+    P2A(P2ABytes),
 }
 
-impl Addressbytes {
+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[..],
+            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[..],
+            AddressBytes::P2A(bytes) => &bytes[..],
         }
     }
 }
 
-impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
+impl TryFrom<(&ScriptBuf, OutputType)> for AddressBytes {
     type Error = Error;
-    fn try_from(tuple: (&ScriptBuf, Addresstype)) -> Result<Self, Self::Error> {
-        let (script, addresstype) = tuple;
+    fn try_from(tuple: (&ScriptBuf, OutputType)) -> Result<Self, Self::Error> {
+        let (script, outputtype) = tuple;
 
-        match addresstype {
-            Addresstype::P2PK65 => {
+        match outputtype {
+            OutputType::P2PK65 => {
                 let bytes = script.as_bytes();
                 let bytes = match bytes.len() {
                     67 => &bytes[1..66],
@@ -54,9 +56,9 @@ impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
                         return Err(Error::WrongLength);
                     }
                 };
-                Ok(Self::P2PK65(P2PK65AddressBytes(U8x65::from(bytes))))
+                Ok(Self::P2PK65(P2PK65Bytes(U8x65::from(bytes))))
             }
-            Addresstype::P2PK33 => {
+            OutputType::P2PK33 => {
                 let bytes = script.as_bytes();
                 let bytes = match bytes.len() {
                     35 => &bytes[1..34],
@@ -65,47 +67,50 @@ impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
                         return Err(Error::WrongLength);
                     }
                 };
-                Ok(Self::P2PK33(P2PK33AddressBytes(U8x33::from(bytes))))
+                Ok(Self::P2PK33(P2PK33Bytes(U8x33::from(bytes))))
             }
-            Addresstype::P2PKH => {
+            OutputType::P2PKH => {
                 let bytes = &script.as_bytes()[3..23];
-                Ok(Self::P2PKH(P2PKHAddressBytes(U8x20::from(bytes))))
+                Ok(Self::P2PKH(P2PKHBytes(U8x20::from(bytes))))
             }
-            Addresstype::P2SH => {
+            OutputType::P2SH => {
                 let bytes = &script.as_bytes()[2..22];
-                Ok(Self::P2SH(P2SHAddressBytes(U8x20::from(bytes))))
+                Ok(Self::P2SH(P2SHBytes(U8x20::from(bytes))))
             }
-            Addresstype::P2WPKH => {
+            OutputType::P2WPKH => {
                 let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2WPKH(P2WPKHAddressBytes(U8x20::from(bytes))))
+                Ok(Self::P2WPKH(P2WPKHBytes(U8x20::from(bytes))))
             }
-            Addresstype::P2WSH => {
+            OutputType::P2WSH => {
                 let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2WSH(P2WSHAddressBytes(U8x32::from(bytes))))
+                Ok(Self::P2WSH(P2WSHBytes(U8x32::from(bytes))))
             }
-            Addresstype::P2TR => {
+            OutputType::P2TR => {
                 let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2TR(P2TRAddressBytes(U8x32::from(bytes))))
+                Ok(Self::P2TR(P2TRBytes(U8x32::from(bytes))))
             }
-            Addresstype::Multisig => Err(Error::WrongAddressType),
-            Addresstype::PushOnly => Err(Error::WrongAddressType),
-            Addresstype::Unknown => Err(Error::WrongAddressType),
-            Addresstype::Empty => Err(Error::WrongAddressType),
-            Addresstype::OpReturn => Err(Error::WrongAddressType),
+            OutputType::P2A => {
+                let bytes = &script.as_bytes()[2..];
+                Ok(Self::P2A(P2ABytes(U8x2::from(bytes))))
+            }
+            OutputType::P2MS => Err(Error::WrongAddressType),
+            OutputType::Unknown => Err(Error::WrongAddressType),
+            OutputType::Empty => Err(Error::WrongAddressType),
+            OutputType::OpReturn => Err(Error::WrongAddressType),
         }
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2PK65AddressBytes(U8x65);
+pub struct P2PK65Bytes(U8x65);
 
-impl fmt::Display for P2PK65AddressBytes {
+impl fmt::Display for P2PK65Bytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.to_hex_string(Case::Lower))
     }
 }
 
-impl Serialize for P2PK65AddressBytes {
+impl Serialize for P2PK65Bytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -114,22 +119,22 @@ impl Serialize for P2PK65AddressBytes {
     }
 }
 
-impl From<P2PK65AddressBytes> for Addressbytes {
-    fn from(value: P2PK65AddressBytes) -> Self {
+impl From<P2PK65Bytes> for AddressBytes {
+    fn from(value: P2PK65Bytes) -> Self {
         Self::P2PK65(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2PK33AddressBytes(U8x33);
+pub struct P2PK33Bytes(U8x33);
 
-impl fmt::Display for P2PK33AddressBytes {
+impl fmt::Display for P2PK33Bytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.to_hex_string(Case::Lower))
     }
 }
 
-impl Serialize for P2PK33AddressBytes {
+impl Serialize for P2PK33Bytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -138,16 +143,16 @@ impl Serialize for P2PK33AddressBytes {
     }
 }
 
-impl From<P2PK33AddressBytes> for Addressbytes {
-    fn from(value: P2PK33AddressBytes) -> Self {
+impl From<P2PK33Bytes> for AddressBytes {
+    fn from(value: P2PK33Bytes) -> Self {
         Self::P2PK33(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2PKHAddressBytes(U8x20);
+pub struct P2PKHBytes(U8x20);
 
-impl fmt::Display for P2PKHAddressBytes {
+impl fmt::Display for P2PKHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new()
             .push_opcode(opcodes::all::OP_DUP)
@@ -161,7 +166,7 @@ impl fmt::Display for P2PKHAddressBytes {
     }
 }
 
-impl Serialize for P2PKHAddressBytes {
+impl Serialize for P2PKHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -170,16 +175,16 @@ impl Serialize for P2PKHAddressBytes {
     }
 }
 
-impl From<P2PKHAddressBytes> for Addressbytes {
-    fn from(value: P2PKHAddressBytes) -> Self {
+impl From<P2PKHBytes> for AddressBytes {
+    fn from(value: P2PKHBytes) -> Self {
         Self::P2PKH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2SHAddressBytes(U8x20);
+pub struct P2SHBytes(U8x20);
 
-impl fmt::Display for P2SHAddressBytes {
+impl fmt::Display for P2SHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new()
             .push_opcode(opcodes::all::OP_HASH160)
@@ -191,7 +196,7 @@ impl fmt::Display for P2SHAddressBytes {
     }
 }
 
-impl Serialize for P2SHAddressBytes {
+impl Serialize for P2SHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -200,16 +205,16 @@ impl Serialize for P2SHAddressBytes {
     }
 }
 
-impl From<P2SHAddressBytes> for Addressbytes {
-    fn from(value: P2SHAddressBytes) -> Self {
+impl From<P2SHBytes> for AddressBytes {
+    fn from(value: P2SHBytes) -> Self {
         Self::P2SH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2WPKHAddressBytes(U8x20);
+pub struct P2WPKHBytes(U8x20);
 
-impl fmt::Display for P2WPKHAddressBytes {
+impl fmt::Display for P2WPKHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(0).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
@@ -217,7 +222,7 @@ impl fmt::Display for P2WPKHAddressBytes {
     }
 }
 
-impl Serialize for P2WPKHAddressBytes {
+impl Serialize for P2WPKHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -226,16 +231,16 @@ impl Serialize for P2WPKHAddressBytes {
     }
 }
 
-impl From<P2WPKHAddressBytes> for Addressbytes {
-    fn from(value: P2WPKHAddressBytes) -> Self {
+impl From<P2WPKHBytes> for AddressBytes {
+    fn from(value: P2WPKHBytes) -> Self {
         Self::P2WPKH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2WSHAddressBytes(U8x32);
+pub struct P2WSHBytes(U8x32);
 
-impl fmt::Display for P2WSHAddressBytes {
+impl fmt::Display for P2WSHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(0).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
@@ -243,7 +248,7 @@ impl fmt::Display for P2WSHAddressBytes {
     }
 }
 
-impl Serialize for P2WSHAddressBytes {
+impl Serialize for P2WSHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -252,16 +257,16 @@ impl Serialize for P2WSHAddressBytes {
     }
 }
 
-impl From<P2WSHAddressBytes> for Addressbytes {
-    fn from(value: P2WSHAddressBytes) -> Self {
+impl From<P2WSHBytes> for AddressBytes {
+    fn from(value: P2WSHBytes) -> Self {
         Self::P2WSH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2TRAddressBytes(U8x32);
+pub struct P2TRBytes(U8x32);
 
-impl fmt::Display for P2TRAddressBytes {
+impl fmt::Display for P2TRBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(1).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
@@ -269,7 +274,7 @@ impl fmt::Display for P2TRAddressBytes {
     }
 }
 
-impl Serialize for P2TRAddressBytes {
+impl Serialize for P2TRBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -278,12 +283,60 @@ impl Serialize for P2TRAddressBytes {
     }
 }
 
-impl From<P2TRAddressBytes> for Addressbytes {
-    fn from(value: P2TRAddressBytes) -> Self {
+impl From<P2TRBytes> for AddressBytes {
+    fn from(value: P2TRBytes) -> Self {
         Self::P2TR(value)
     }
 }
 
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
+pub struct P2ABytes(U8x2);
+
+impl fmt::Display for P2ABytes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let script = Builder::new().push_int(1).push_slice(*self.0).into_script();
+        let address = Address::from_script(&script, Network::Bitcoin).unwrap();
+        write!(f, "{}", address)
+    }
+}
+
+impl Serialize for P2ABytes {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_str(&self.to_string())
+    }
+}
+
+impl From<P2ABytes> for AddressBytes {
+    fn from(value: P2ABytes) -> Self {
+        Self::P2A(value)
+    }
+}
+
+#[derive(
+    Debug,
+    Clone,
+    Deref,
+    DerefMut,
+    PartialEq,
+    Eq,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    FromBytes,
+    Serialize,
+)]
+pub struct U8x2([u8; 2]);
+impl From<&[u8]> for U8x2 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 2];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}
+
 #[derive(
     Debug,
     Clone,

crates/brk_core/src/structs/addressbyteshash.rs

@@ -0,0 +1,60 @@
+use std::hash::Hasher;
+
+use byteview::ByteView;
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::Error;
+
+use super::{AddressBytes, OutputType};
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
+pub struct AddressBytesHash([u8; 8]);
+
+impl From<(&AddressBytes, OutputType)> for AddressBytesHash {
+    fn from((address_bytes, outputtype): (&AddressBytes, OutputType)) -> Self {
+        let mut hasher = rapidhash::RapidHasher::default();
+        hasher.write(address_bytes.as_slice());
+        let mut slice = hasher.finish().to_le_bytes();
+        slice[0] = slice[0].wrapping_add(outputtype as u8);
+        Self(slice)
+    }
+}
+
+impl From<[u8; 8]> for AddressBytesHash {
+    fn from(value: [u8; 8]) -> Self {
+        Self(value)
+    }
+}
+
+impl TryFrom<ByteView> for AddressBytesHash {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+
+impl From<&AddressBytesHash> for ByteView {
+    fn from(value: &AddressBytesHash) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+
+impl From<AddressBytesHash> for ByteView {
+    fn from(value: AddressBytesHash) -> Self {
+        Self::from(&value)
+    }
+}

crates/brk_core/src/structs/addressindextxoutindex.rs

@@ -1,26 +0,0 @@
-use byteview::ByteView;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use crate::Error;
-
-use super::{Addressindex, Txoutindex};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Immutable, IntoBytes, KnownLayout, FromBytes)]
-#[repr(C)]
-pub struct AddressindexTxoutindex {
-    addressindex: Addressindex,
-    _padding: u32,
-    txoutindex: Txoutindex,
-}
-
-impl TryFrom<ByteView> for AddressindexTxoutindex {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<AddressindexTxoutindex> for ByteView {
-    fn from(value: AddressindexTxoutindex) -> Self {
-        Self::new(value.as_bytes())
-    }
-}

crates/brk_core/src/structs/blockhashprefix.rs

@@ -0,0 +1,54 @@
+use byteview::ByteView;
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{Error, copy_first_8bytes};
+
+use super::BlockHash;
+
+#[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::from(&value)
+    }
+}
+
+impl From<&BlockHash> for BlockHashPrefix {
+    fn from(value: &BlockHash) -> Self {
+        Self(copy_first_8bytes(&value[..]).unwrap())
+    }
+}
+
+impl TryFrom<ByteView> for BlockHashPrefix {
+    type Error = 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)
+    }
+}

crates/brk_core/src/structs/compressed.rs

@@ -1,156 +0,0 @@
-use std::hash::Hasher;
-
-use byteview::ByteView;
-use derive_deref::Deref;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use crate::Error;
-
-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 = 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::from(&value)
-    }
-}
-impl From<&BlockHash> for BlockHashPrefix {
-    fn from(value: &BlockHash) -> Self {
-        Self(copy_first_8bytes(&value[..]).unwrap())
-    }
-}
-impl TryFrom<ByteView> for BlockHashPrefix {
-    type Error = 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::from(&value)
-    }
-}
-impl From<&Txid> for TxidPrefix {
-    fn from(value: &Txid) -> Self {
-        Self(copy_first_8bytes(&value[..]).unwrap())
-    }
-}
-impl TryFrom<ByteView> for TxidPrefix {
-    type Error = 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)
-    }
-}
-impl From<[u8; 8]> for TxidPrefix {
-    fn from(value: [u8; 8]) -> Self {
-        Self(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_core/src/structs/date.rs

@@ -2,7 +2,7 @@ use jiff::{Span, civil::Date as Date_, tz::TimeZone};
 use serde::{Serialize, Serializer};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use super::{Dateindex, Timestamp};
+use super::{DateIndex, Timestamp};
 
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout,
@@ -58,9 +58,9 @@ impl From<Timestamp> for Date {
     }
 }
 
-impl From<Dateindex> for Date {
-    fn from(value: Dateindex) -> Self {
-        if value == Dateindex::default() {
+impl From<DateIndex> for Date {
+    fn from(value: DateIndex) -> Self {
+        if value == DateIndex::default() {
             Date::INDEX_ZERO
         } else {
             Self::from(

crates/brk_core/src/structs/dateindex.rs

@@ -23,38 +23,38 @@ use super::Date;
     KnownLayout,
     Serialize,
 )]
-pub struct Dateindex(u16);
+pub struct DateIndex(u16);
 
-impl Dateindex {
+impl DateIndex {
     pub const BYTES: usize = size_of::<Self>();
 }
 
-impl From<Dateindex> for usize {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for usize {
+    fn from(value: DateIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl From<usize> for Dateindex {
+impl From<usize> for DateIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Dateindex> for i64 {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for i64 {
+    fn from(value: DateIndex) -> Self {
         value.0 as i64
     }
 }
 
-impl Add<usize> for Dateindex {
+impl Add<usize> for DateIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u16)
     }
 }
 
-impl TryFrom<Date> for Dateindex {
+impl TryFrom<Date> for DateIndex {
     type Error = Error;
     fn try_from(value: Date) -> Result<Self, Self::Error> {
         let value_ = jiff::civil::Date::from(value);
@@ -72,7 +72,7 @@ impl TryFrom<Date> for Dateindex {
     }
 }
 
-impl CheckedSub for Dateindex {
+impl CheckedSub for DateIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/decadeindex.rs

@@ -5,7 +5,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex, Yearindex};
+use super::{Date, DateIndex, YearIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex, Yearindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Decadeindex(u8);
+pub struct DecadeIndex(u8);
 
-impl From<u8> for Decadeindex {
+impl From<u8> for DecadeIndex {
     fn from(value: u8) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Decadeindex {
+impl From<usize> for DecadeIndex {
     fn from(value: usize) -> Self {
         Self(value as u8)
     }
 }
 
-impl From<Decadeindex> for usize {
-    fn from(value: Decadeindex) -> Self {
+impl From<DecadeIndex> for usize {
+    fn from(value: DecadeIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Decadeindex {
+impl Add<usize> for DecadeIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Decadeindex {
     }
 }
 
-impl From<Dateindex> for Decadeindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for DecadeIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Decadeindex {
+impl From<Date> for DecadeIndex {
     fn from(value: Date) -> Self {
         let year = value.year();
         if year < 2000 {
@@ -67,14 +67,14 @@ impl From<Date> for Decadeindex {
     }
 }
 
-impl CheckedSub for Decadeindex {
+impl CheckedSub for DecadeIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
 
-impl From<Yearindex> for Decadeindex {
-    fn from(value: Yearindex) -> Self {
+impl From<YearIndex> for DecadeIndex {
+    fn from(value: YearIndex) -> Self {
         let v = usize::from(value);
         if v == 0 {
             Self(0)

crates/brk_core/src/structs/difficultyepoch.rs

@@ -23,27 +23,27 @@ use super::Height;
     IntoBytes,
     KnownLayout,
 )]
-pub struct Difficultyepoch(u16);
+pub struct DifficultyEpoch(u16);
 
-impl From<u16> for Difficultyepoch {
+impl From<u16> for DifficultyEpoch {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Difficultyepoch {
+impl From<usize> for DifficultyEpoch {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Difficultyepoch> for usize {
-    fn from(value: Difficultyepoch) -> Self {
+impl From<DifficultyEpoch> for usize {
+    fn from(value: DifficultyEpoch) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Difficultyepoch {
+impl Add<usize> for DifficultyEpoch {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Difficultyepoch {
     }
 }
 
-impl From<Height> for Difficultyepoch {
+impl From<Height> for DifficultyEpoch {
     fn from(value: Height) -> Self {
         Self((u32::from(value) / 2016) as u16)
     }
 }
 
-impl CheckedSub for Difficultyepoch {
+impl CheckedSub for DifficultyEpoch {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/halvingepoch.rs

@@ -23,27 +23,27 @@ use super::Height;
     IntoBytes,
     KnownLayout,
 )]
-pub struct Halvingepoch(u8);
+pub struct HalvingEpoch(u8);
 
-impl From<u8> for Halvingepoch {
+impl From<u8> for HalvingEpoch {
     fn from(value: u8) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Halvingepoch {
+impl From<usize> for HalvingEpoch {
     fn from(value: usize) -> Self {
         Self(value as u8)
     }
 }
 
-impl From<Halvingepoch> for usize {
-    fn from(value: Halvingepoch) -> Self {
+impl From<HalvingEpoch> for usize {
+    fn from(value: HalvingEpoch) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Halvingepoch {
+impl Add<usize> for HalvingEpoch {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Halvingepoch {
     }
 }
 
-impl From<Height> for Halvingepoch {
+impl From<Height> for HalvingEpoch {
     fn from(value: Height) -> Self {
         Self((u32::from(value) / 210_000) as u8)
     }
 }
 
-impl CheckedSub for Halvingepoch {
+impl CheckedSub for HalvingEpoch {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/inputindex.rs

@@ -25,49 +25,49 @@ use super::Vin;
     KnownLayout,
     Serialize,
 )]
-pub struct Txinindex(u64);
+pub struct InputIndex(u64);
 
-impl Txinindex {
+impl InputIndex {
     pub fn incremented(self) -> Self {
         Self(*self + 1)
     }
 }
 
-impl Add<Txinindex> for Txinindex {
+impl Add<InputIndex> for InputIndex {
     type Output = Self;
-    fn add(self, rhs: Txinindex) -> Self::Output {
+    fn add(self, rhs: InputIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
 
-impl Add<Vin> for Txinindex {
+impl Add<Vin> for InputIndex {
     type Output = Self;
     fn add(self, rhs: Vin) -> Self::Output {
         Self(self.0 + u64::from(rhs))
     }
 }
 
-impl Add<usize> for Txinindex {
+impl Add<usize> for InputIndex {
     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) {
+impl AddAssign<InputIndex> for InputIndex {
+    fn add_assign(&mut self, rhs: InputIndex) {
         self.0 += rhs.0
     }
 }
 
-impl CheckedSub<Txinindex> for Txinindex {
+impl CheckedSub<InputIndex> for InputIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self::from)
     }
 }
 
-impl From<Txinindex> for u32 {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for u32 {
+    fn from(value: InputIndex) -> Self {
         if value.0 > u32::MAX as u64 {
             panic!()
         }
@@ -75,24 +75,24 @@ impl From<Txinindex> for u32 {
     }
 }
 
-impl From<u64> for Txinindex {
+impl From<u64> for InputIndex {
     fn from(value: u64) -> Self {
         Self(value)
     }
 }
-impl From<Txinindex> for u64 {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for u64 {
+    fn from(value: InputIndex) -> Self {
         value.0
     }
 }
 
-impl From<usize> for Txinindex {
+impl From<usize> for InputIndex {
     fn from(value: usize) -> Self {
         Self(value as u64)
     }
 }
-impl From<Txinindex> for usize {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for usize {
+    fn from(value: InputIndex) -> Self {
         value.0 as usize
     }
 }

crates/brk_core/src/structs/mod.rs

@@ -1,12 +1,12 @@
 mod addressbytes;
-mod addressindex;
-mod addressindextxoutindex;
-mod addresstype;
-mod addresstypeindex;
+mod addressbyteshash;
+// mod addressindex;
+// mod addressindexoutputindex;
+// mod addresstype;
 mod bitcoin;
 mod blockhash;
+mod blockhashprefix;
 mod cents;
-mod compressed;
 mod date;
 mod dateindex;
 mod decadeindex;
@@ -15,8 +15,12 @@ mod dollars;
 mod feerate;
 mod halvingepoch;
 mod height;
+mod inputindex;
 mod monthindex;
 mod ohlc;
+mod outputindex;
+mod outputtype;
+mod outputtypeindex;
 mod quarterindex;
 mod rawlocktime;
 mod sats;
@@ -26,9 +30,8 @@ mod stored_u8;
 mod stored_usize;
 mod timestamp;
 mod txid;
+mod txidprefix;
 mod txindex;
-mod txinindex;
-mod txoutindex;
 mod txversion;
 mod unit;
 mod vin;
@@ -38,14 +41,14 @@ mod weight;
 mod yearindex;
 
 pub use addressbytes::*;
-pub use addressindex::*;
-pub use addressindextxoutindex::*;
-pub use addresstype::*;
-pub use addresstypeindex::*;
+pub use addressbyteshash::*;
+// pub use addressindex::*;
+// pub use addressindexoutputindex::*;
+// pub use addresstype::*;
 pub use bitcoin::*;
 pub use blockhash::*;
+pub use blockhashprefix::*;
 pub use cents::*;
-pub use compressed::*;
 pub use date::*;
 pub use dateindex::*;
 pub use decadeindex::*;
@@ -54,8 +57,12 @@ pub use dollars::*;
 pub use feerate::*;
 pub use halvingepoch::*;
 pub use height::*;
+pub use inputindex::*;
 pub use monthindex::*;
 pub use ohlc::*;
+pub use outputindex::*;
+pub use outputtype::*;
+pub use outputtypeindex::*;
 pub use quarterindex::*;
 pub use rawlocktime::*;
 pub use sats::*;
@@ -65,9 +72,8 @@ pub use stored_u64::*;
 pub use stored_usize::*;
 pub use timestamp::*;
 pub use txid::*;
+pub use txidprefix::*;
 pub use txindex::*;
-pub use txinindex::*;
-pub use txoutindex::*;
 pub use txversion::*;
 pub use unit::*;
 pub use vin::*;

crates/brk_core/src/structs/monthindex.rs

@@ -5,7 +5,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex, Yearindex};
+use super::{Date, DateIndex, YearIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex, Yearindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Monthindex(u16);
+pub struct MonthIndex(u16);
 
-impl From<u16> for Monthindex {
+impl From<u16> for MonthIndex {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Monthindex {
+impl From<usize> for MonthIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Monthindex> for usize {
-    fn from(value: Monthindex) -> Self {
+impl From<MonthIndex> for usize {
+    fn from(value: MonthIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Monthindex {
+impl Add<usize> for MonthIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,19 +51,19 @@ impl Add<usize> for Monthindex {
     }
 }
 
-impl From<Dateindex> for Monthindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for MonthIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Monthindex {
+impl From<Date> for MonthIndex {
     fn from(value: Date) -> Self {
-        Self(u16::from(Yearindex::from(value)) * 12 + value.month() as u16 - 1)
+        Self(u16::from(YearIndex::from(value)) * 12 + value.month() as u16 - 1)
     }
 }
 
-impl CheckedSub for Monthindex {
+impl CheckedSub for MonthIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/outputindex.rs

@@ -25,9 +25,9 @@ use super::Vout;
     KnownLayout,
     Serialize,
 )]
-pub struct Txoutindex(u64);
+pub struct OutputIndex(u64);
 
-impl Txoutindex {
+impl OutputIndex {
     pub const COINBASE: Self = Self(u64::MAX);
 
     pub fn incremented(self) -> Self {
@@ -39,41 +39,41 @@ impl Txoutindex {
     }
 }
 
-impl Add<Txoutindex> for Txoutindex {
+impl Add<OutputIndex> for OutputIndex {
     type Output = Self;
-    fn add(self, rhs: Txoutindex) -> Self::Output {
+    fn add(self, rhs: OutputIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
 
-impl Add<Vout> for Txoutindex {
+impl Add<Vout> for OutputIndex {
     type Output = Self;
     fn add(self, rhs: Vout) -> Self::Output {
         Self(self.0 + u64::from(rhs))
     }
 }
 
-impl Add<usize> for Txoutindex {
+impl Add<usize> for OutputIndex {
     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) {
+impl AddAssign<OutputIndex> for OutputIndex {
+    fn add_assign(&mut self, rhs: OutputIndex) {
         self.0 += rhs.0
     }
 }
 
-impl CheckedSub<Txoutindex> for Txoutindex {
+impl CheckedSub<OutputIndex> for OutputIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self::from)
     }
 }
 
-impl From<Txoutindex> for u32 {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for u32 {
+    fn from(value: OutputIndex) -> Self {
         if value.0 > u32::MAX as u64 {
             panic!()
         }
@@ -81,24 +81,24 @@ impl From<Txoutindex> for u32 {
     }
 }
 
-impl From<u64> for Txoutindex {
+impl From<u64> for OutputIndex {
     fn from(value: u64) -> Self {
         Self(value)
     }
 }
-impl From<Txoutindex> for u64 {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for u64 {
+    fn from(value: OutputIndex) -> Self {
         value.0
     }
 }
 
-impl From<usize> for Txoutindex {
+impl From<usize> for OutputIndex {
     fn from(value: usize) -> Self {
         Self(value as u64)
     }
 }
-impl From<Txoutindex> for usize {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for usize {
+    fn from(value: OutputIndex) -> Self {
         value.0 as usize
     }
 }

crates/brk_core/src/structs/outputtype.rs

@@ -1,27 +1,38 @@
-use bitcoin::ScriptBuf;
+use bitcoin::{ScriptBuf, opcodes::all::OP_PUSHBYTES_2};
 use serde::Serialize;
 use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
 
 #[derive(
-    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, TryFromBytes, Immutable, IntoBytes, KnownLayout, Serialize,
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    TryFromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
 )]
 #[repr(u8)]
-pub enum Addresstype {
+pub enum OutputType {
     P2PK65,
     P2PK33,
     P2PKH,
+    P2MS,
     P2SH,
+    OpReturn,
     P2WPKH,
     P2WSH,
     P2TR,
-    Multisig = 251,
-    PushOnly = 252,
-    OpReturn = 253,
+    P2A,
     Empty = 254,
     Unknown = 255,
 }
 
-impl From<&ScriptBuf> for Addresstype {
+impl From<&ScriptBuf> for OutputType {
     fn from(script: &ScriptBuf) -> Self {
         if script.is_p2pk() {
             let bytes = script.as_bytes();
@@ -36,22 +47,26 @@ impl From<&ScriptBuf> for Addresstype {
             }
         } else if script.is_p2pkh() {
             Self::P2PKH
+        } else if script.is_multisig() {
+            Self::P2MS
         } else if script.is_p2sh() {
             Self::P2SH
+        } else if script.is_op_return() {
+            Self::OpReturn
         } else if script.is_p2wpkh() {
             Self::P2WPKH
         } else if script.is_p2wsh() {
             Self::P2WSH
         } else if script.is_p2tr() {
             Self::P2TR
+        } else if script.witness_version() == Some(bitcoin::WitnessVersion::V1)
+            && script.len() == 4
+            && script.as_bytes()[1] == OP_PUSHBYTES_2.to_u8()
+            && script.as_bytes()[2..4] == [78, 115]
+        {
+            Self::P2A
         } 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_core/src/structs/outputtypeindex.rs

@@ -1,9 +1,12 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
+use crate::Error;
+
 #[derive(
     Debug,
     PartialEq,
@@ -19,9 +22,9 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
     KnownLayout,
     Serialize,
 )]
-pub struct Addresstypeindex(u32);
+pub struct OutputTypeIndex(u32);
 
-impl Addresstypeindex {
+impl OutputTypeIndex {
     pub fn increment(&mut self) {
         self.0 += 1;
     }
@@ -37,47 +40,58 @@ impl Addresstypeindex {
     }
 }
 
-impl From<u32> for Addresstypeindex {
+impl From<u32> for OutputTypeIndex {
     fn from(value: u32) -> Self {
         Self(value)
     }
 }
 
-impl From<u64> for Addresstypeindex {
+impl From<u64> for OutputTypeIndex {
     fn from(value: u64) -> Self {
         Self(value as u32)
     }
 }
-impl From<Addresstypeindex> for u64 {
-    fn from(value: Addresstypeindex) -> Self {
+impl From<OutputTypeIndex> for u64 {
+    fn from(value: OutputTypeIndex) -> Self {
         value.0 as u64
     }
 }
 
-impl From<usize> for Addresstypeindex {
+impl From<usize> for OutputTypeIndex {
     fn from(value: usize) -> Self {
         Self(value as u32)
     }
 }
-impl From<Addresstypeindex> for usize {
-    fn from(value: Addresstypeindex) -> Self {
+impl From<OutputTypeIndex> for usize {
+    fn from(value: OutputTypeIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Addresstypeindex {
+impl Add<usize> for OutputTypeIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u32)
     }
 }
 
-impl Add<Addresstypeindex> for Addresstypeindex {
+impl Add<OutputTypeIndex> for OutputTypeIndex {
     type Output = Self;
-    fn add(self, rhs: Addresstypeindex) -> Self::Output {
+    fn add(self, rhs: OutputTypeIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
+impl TryFrom<ByteView> for OutputTypeIndex {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<OutputTypeIndex> for ByteView {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
 
 #[derive(
     Debug,
@@ -96,23 +110,23 @@ impl Add<Addresstypeindex> for Addresstypeindex {
     KnownLayout,
     Serialize,
 )]
-pub struct Emptyindex(Addresstypeindex);
-impl From<Addresstypeindex> for Emptyindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct EmptyOutputIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for EmptyOutputIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<Emptyindex> for usize {
-    fn from(value: Emptyindex) -> Self {
+impl From<EmptyOutputIndex> for usize {
+    fn from(value: EmptyOutputIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for Emptyindex {
+impl From<usize> for EmptyOutputIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for Emptyindex {
+impl Add<usize> for EmptyOutputIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -136,23 +150,23 @@ impl Add<usize> for Emptyindex {
     KnownLayout,
     Serialize,
 )]
-pub struct Multisigindex(Addresstypeindex);
-impl From<Addresstypeindex> for Multisigindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2MSIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2MSIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<Multisigindex> for usize {
-    fn from(value: Multisigindex) -> Self {
+impl From<P2MSIndex> for usize {
+    fn from(value: P2MSIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for Multisigindex {
+impl From<usize> for P2MSIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for Multisigindex {
+impl Add<usize> for P2MSIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -176,23 +190,23 @@ impl Add<usize> for Multisigindex {
     KnownLayout,
     Serialize,
 )]
-pub struct Opreturnindex(Addresstypeindex);
-impl From<Addresstypeindex> for Opreturnindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2AIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2AIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<Opreturnindex> for usize {
-    fn from(value: Opreturnindex) -> Self {
+impl From<P2AIndex> for usize {
+    fn from(value: P2AIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for Opreturnindex {
+impl From<usize> for P2AIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for Opreturnindex {
+impl Add<usize> for P2AIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -216,23 +230,23 @@ impl Add<usize> for Opreturnindex {
     KnownLayout,
     Serialize,
 )]
-pub struct Pushonlyindex(Addresstypeindex);
-impl From<Addresstypeindex> for Pushonlyindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct OpReturnIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for OpReturnIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<Pushonlyindex> for usize {
-    fn from(value: Pushonlyindex) -> Self {
+impl From<OpReturnIndex> for usize {
+    fn from(value: OpReturnIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for Pushonlyindex {
+impl From<usize> for OpReturnIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for Pushonlyindex {
+impl Add<usize> for OpReturnIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -256,23 +270,23 @@ impl Add<usize> for Pushonlyindex {
     KnownLayout,
     Serialize,
 )]
-pub struct Unknownindex(Addresstypeindex);
-impl From<Addresstypeindex> for Unknownindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct UnknownOutputIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for UnknownOutputIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<Unknownindex> for usize {
-    fn from(value: Unknownindex) -> Self {
+impl From<UnknownOutputIndex> for usize {
+    fn from(value: UnknownOutputIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for Unknownindex {
+impl From<usize> for UnknownOutputIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for Unknownindex {
+impl Add<usize> for UnknownOutputIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -296,23 +310,23 @@ impl Add<usize> for Unknownindex {
     KnownLayout,
     Serialize,
 )]
-pub struct P2PK33index(Addresstypeindex);
-impl From<Addresstypeindex> for P2PK33index {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2PK33Index(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2PK33Index {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2PK33index> for usize {
-    fn from(value: P2PK33index) -> Self {
+impl From<P2PK33Index> for usize {
+    fn from(value: P2PK33Index) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2PK33index {
+impl From<usize> for P2PK33Index {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2PK33index {
+impl Add<usize> for P2PK33Index {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -336,23 +350,23 @@ impl Add<usize> for P2PK33index {
     KnownLayout,
     Serialize,
 )]
-pub struct P2PK65index(Addresstypeindex);
-impl From<Addresstypeindex> for P2PK65index {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2PK65Index(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2PK65Index {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2PK65index> for usize {
-    fn from(value: P2PK65index) -> Self {
+impl From<P2PK65Index> for usize {
+    fn from(value: P2PK65Index) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2PK65index {
+impl From<usize> for P2PK65Index {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2PK65index {
+impl Add<usize> for P2PK65Index {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -376,23 +390,23 @@ impl Add<usize> for P2PK65index {
     KnownLayout,
     Serialize,
 )]
-pub struct P2PKHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2PKHindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2PKHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2PKHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2PKHindex> for usize {
-    fn from(value: P2PKHindex) -> Self {
+impl From<P2PKHIndex> for usize {
+    fn from(value: P2PKHIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2PKHindex {
+impl From<usize> for P2PKHIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2PKHindex {
+impl Add<usize> for P2PKHIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -416,23 +430,23 @@ impl Add<usize> for P2PKHindex {
     KnownLayout,
     Serialize,
 )]
-pub struct P2SHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2SHindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2SHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2SHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2SHindex> for usize {
-    fn from(value: P2SHindex) -> Self {
+impl From<P2SHIndex> for usize {
+    fn from(value: P2SHIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2SHindex {
+impl From<usize> for P2SHIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2SHindex {
+impl Add<usize> for P2SHIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -456,23 +470,23 @@ impl Add<usize> for P2SHindex {
     KnownLayout,
     Serialize,
 )]
-pub struct P2TRindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2TRindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2TRIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2TRIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2TRindex> for usize {
-    fn from(value: P2TRindex) -> Self {
+impl From<P2TRIndex> for usize {
+    fn from(value: P2TRIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2TRindex {
+impl From<usize> for P2TRIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2TRindex {
+impl Add<usize> for P2TRIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -496,23 +510,23 @@ impl Add<usize> for P2TRindex {
     KnownLayout,
     Serialize,
 )]
-pub struct P2WPKHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2WPKHindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2WPKHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2WPKHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2WPKHindex> for usize {
-    fn from(value: P2WPKHindex) -> Self {
+impl From<P2WPKHIndex> for usize {
+    fn from(value: P2WPKHIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2WPKHindex {
+impl From<usize> for P2WPKHIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2WPKHindex {
+impl Add<usize> for P2WPKHIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)
@@ -536,23 +550,23 @@ impl Add<usize> for P2WPKHindex {
     KnownLayout,
     Serialize,
 )]
-pub struct P2WSHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2WSHindex {
-    fn from(value: Addresstypeindex) -> Self {
+pub struct P2WSHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2WSHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
         Self(value)
     }
 }
-impl From<P2WSHindex> for usize {
-    fn from(value: P2WSHindex) -> Self {
+impl From<P2WSHIndex> for usize {
+    fn from(value: P2WSHIndex) -> Self {
         Self::from(*value)
     }
 }
-impl From<usize> for P2WSHindex {
+impl From<usize> for P2WSHIndex {
     fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
+        Self(OutputTypeIndex::from(value))
     }
 }
-impl Add<usize> for P2WSHindex {
+impl Add<usize> for P2WSHIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(*self + rhs)

crates/brk_core/src/structs/quarterindex.rs

@@ -5,7 +5,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::Monthindex;
+use super::MonthIndex;
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::Monthindex;
     IntoBytes,
     KnownLayout,
 )]
-pub struct Quarterindex(u16);
+pub struct QuarterIndex(u16);
 
-impl From<u16> for Quarterindex {
+impl From<u16> for QuarterIndex {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Quarterindex {
+impl From<usize> for QuarterIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Quarterindex> for usize {
-    fn from(value: Quarterindex) -> Self {
+impl From<QuarterIndex> for usize {
+    fn from(value: QuarterIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Quarterindex {
+impl Add<usize> for QuarterIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Quarterindex {
     }
 }
 
-impl From<Monthindex> for Quarterindex {
-    fn from(value: Monthindex) -> Self {
+impl From<MonthIndex> for QuarterIndex {
+    fn from(value: MonthIndex) -> Self {
         Self((usize::from(value) / 3) as u16)
     }
 }
 
-impl CheckedSub for Quarterindex {
+impl CheckedSub for QuarterIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/stored_u32.rs

@@ -39,6 +39,9 @@ impl From<u32> for StoredU32 {
 
 impl From<usize> for StoredU32 {
     fn from(value: usize) -> Self {
+        if value > u32::MAX as usize {
+            panic!("usize too big (value = {value})")
+        }
         Self(value as u32)
     }
 }
@@ -77,3 +80,9 @@ impl From<StoredU32> for f64 {
         value.0 as f64
     }
 }
+
+impl From<StoredU32> for usize {
+    fn from(value: StoredU32) -> Self {
+        value.0 as usize
+    }
+}

crates/brk_core/src/structs/stored_u64.rs

@@ -6,7 +6,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Txindex, Txinindex, Txoutindex};
+use super::{InputIndex, OutputIndex, TxIndex};
 
 #[derive(
     Debug,
@@ -80,20 +80,20 @@ impl From<StoredU64> for f64 {
     }
 }
 
-impl From<Txindex> for StoredU64 {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for StoredU64 {
+    fn from(value: TxIndex) -> Self {
         Self(*value as u64)
     }
 }
 
-impl From<Txinindex> for StoredU64 {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for StoredU64 {
+    fn from(value: InputIndex) -> Self {
         Self(*value)
     }
 }
 
-impl From<Txoutindex> for StoredU64 {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for StoredU64 {
+    fn from(value: OutputIndex) -> Self {
         Self(*value)
     }
 }

crates/brk_core/src/structs/txidprefix.rs

@@ -0,0 +1,60 @@
+use byteview::ByteView;
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{Error, copy_first_8bytes};
+
+use super::Txid;
+
+#[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::from(&value)
+    }
+}
+
+impl From<&Txid> for TxidPrefix {
+    fn from(value: &Txid) -> Self {
+        Self(copy_first_8bytes(&value[..]).unwrap())
+    }
+}
+
+impl TryFrom<ByteView> for TxidPrefix {
+    type Error = 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)
+    }
+}
+
+impl From<[u8; 8]> for TxidPrefix {
+    fn from(value: [u8; 8]) -> Self {
+        Self(value)
+    }
+}

crates/brk_core/src/structs/txindex.rs

@@ -26,82 +26,82 @@ use super::StoredU32;
     KnownLayout,
     Serialize,
 )]
-pub struct Txindex(u32);
+pub struct TxIndex(u32);
 
-impl Txindex {
+impl TxIndex {
     pub fn incremented(self) -> Self {
         Self(*self + 1)
     }
 }
 
-impl Add<Txindex> for Txindex {
+impl Add<TxIndex> for TxIndex {
     type Output = Self;
-    fn add(self, rhs: Txindex) -> Self::Output {
+    fn add(self, rhs: TxIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
 
-impl Add<usize> for Txindex {
+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) {
+impl AddAssign<TxIndex> for TxIndex {
+    fn add_assign(&mut self, rhs: TxIndex) {
         self.0 += rhs.0
     }
 }
 
-impl CheckedSub<Txindex> for Txindex {
-    fn checked_sub(self, rhs: Txindex) -> Option<Self> {
-        self.0.checked_sub(rhs.0).map(Txindex::from)
+impl CheckedSub<TxIndex> for TxIndex {
+    fn checked_sub(self, rhs: TxIndex) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(TxIndex::from)
     }
 }
 
-impl From<u32> for Txindex {
+impl From<u32> for TxIndex {
     fn from(value: u32) -> Self {
         Self(value)
     }
 }
 
-impl From<u64> for Txindex {
+impl From<u64> for TxIndex {
     fn from(value: u64) -> Self {
         Self(value as u32)
     }
 }
-impl From<Txindex> for u64 {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for u64 {
+    fn from(value: TxIndex) -> Self {
         value.0 as u64
     }
 }
 
-impl From<usize> for Txindex {
+impl From<usize> for TxIndex {
     fn from(value: usize) -> Self {
         Self(value as u32)
     }
 }
-impl From<Txindex> for usize {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for usize {
+    fn from(value: TxIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl TryFrom<ByteView> for Txindex {
+impl TryFrom<ByteView> for TxIndex {
     type Error = 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 {
+impl From<TxIndex> for ByteView {
+    fn from(value: TxIndex) -> Self {
         Self::new(value.as_bytes())
     }
 }
 
-impl From<Txindex> for StoredU32 {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for StoredU32 {
+    fn from(value: TxIndex) -> Self {
         Self::from(value.0)
     }
 }

crates/brk_core/src/structs/txversion.rs

@@ -19,28 +19,34 @@ use super::StoredU8;
     FromBytes,
     Serialize,
 )]
-pub struct TxVersion(i32);
+pub struct TxVersion(u8);
 
 impl TxVersion {
     pub const ONE: Self = Self(1);
     pub const TWO: Self = Self(2);
     pub const THREE: Self = Self(3);
+    pub const NON_STANDARD: Self = Self(u8::MAX);
 }
 
 impl From<bitcoin::transaction::Version> for TxVersion {
     fn from(value: bitcoin::transaction::Version) -> Self {
-        Self(value.0)
+        match value.0 {
+            1 => Self::ONE,
+            2 => Self::TWO,
+            3 => Self::THREE,
+            _ => Self::NON_STANDARD,
+        }
     }
 }
 
 impl From<TxVersion> for bitcoin::transaction::Version {
     fn from(value: TxVersion) -> Self {
-        Self(value.0)
+        Self(value.0 as i32)
     }
 }
 
 impl From<TxVersion> for StoredU8 {
     fn from(value: TxVersion) -> Self {
-        Self::from(value.0 as u8)
+        Self::from(value.0)
     }
 }

crates/brk_core/src/structs/weekindex.rs

@@ -5,7 +5,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex};
+use super::{Date, DateIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Weekindex(u16);
+pub struct WeekIndex(u16);
 
-impl From<u16> for Weekindex {
+impl From<u16> for WeekIndex {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Weekindex {
+impl From<usize> for WeekIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Weekindex> for usize {
-    fn from(value: Weekindex) -> Self {
+impl From<WeekIndex> for usize {
+    fn from(value: WeekIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Weekindex {
+impl Add<usize> for WeekIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Weekindex {
     }
 }
 
-impl From<Dateindex> for Weekindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for WeekIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Weekindex {
+impl From<Date> for WeekIndex {
     fn from(value: Date) -> Self {
         let date = jiff::civil::Date::from(value).iso_week_date();
 
@@ -81,7 +81,7 @@ impl From<Date> for Weekindex {
     }
 }
 
-impl CheckedSub for Weekindex {
+impl CheckedSub for WeekIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/weight.rs

@@ -19,29 +19,36 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
     FromBytes,
     Serialize,
 )]
-pub struct Weight(u64);
+pub struct Weight(u32);
 
 impl From<bitcoin::Weight> for Weight {
     fn from(value: bitcoin::Weight) -> Self {
-        Self(value.to_wu())
+        let wu = value.to_wu();
+        if wu > u32::MAX as u64 {
+            unreachable!("wu is too big, shouldn't happen")
+        }
+        Self(wu as u32)
     }
 }
 
 impl From<Weight> for bitcoin::Weight {
     fn from(value: Weight) -> Self {
-        Self::from_wu(*value)
+        Self::from_wu(*value as u64)
     }
 }
 
 impl From<usize> for Weight {
     fn from(value: usize) -> Self {
-        Self(value as u64)
+        if value > u32::MAX as usize {
+            panic!()
+        }
+        Self(value as u32)
     }
 }
 
 impl From<f64> for Weight {
     fn from(value: f64) -> Self {
-        Self(value as u64)
+        Self(value as u32)
     }
 }
 

crates/brk_core/src/structs/yearindex.rs

@@ -5,7 +5,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex, Monthindex};
+use super::{Date, DateIndex, MonthIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex, Monthindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Yearindex(u8);
+pub struct YearIndex(u8);
 
-impl From<u8> for Yearindex {
+impl From<u8> for YearIndex {
     fn from(value: u8) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Yearindex {
+impl From<usize> for YearIndex {
     fn from(value: usize) -> Self {
         Self(value as u8)
     }
 }
 
-impl From<Yearindex> for usize {
-    fn from(value: Yearindex) -> Self {
+impl From<YearIndex> for usize {
+    fn from(value: YearIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Yearindex {
+impl Add<usize> for YearIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,32 +51,32 @@ impl Add<usize> for Yearindex {
     }
 }
 
-impl From<Dateindex> for Yearindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for YearIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Yearindex {
+impl From<Date> for YearIndex {
     fn from(value: Date) -> Self {
         Self((value.year() - 2009) as u8)
     }
 }
 
-impl From<Yearindex> for u16 {
-    fn from(value: Yearindex) -> Self {
+impl From<YearIndex> for u16 {
+    fn from(value: YearIndex) -> Self {
         value.0 as u16
     }
 }
 
-impl CheckedSub for Yearindex {
+impl CheckedSub for YearIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
 
-impl From<Monthindex> for Yearindex {
-    fn from(value: Monthindex) -> Self {
+impl From<MonthIndex> for YearIndex {
+    fn from(value: MonthIndex) -> Self {
         Self((usize::from(value) / 12) as u8)
     }
 }

crates/brk_core/src/utils/bytes.rs

@@ -0,0 +1,12 @@
+#[allow(clippy::result_unit_err)]
+pub 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_core/src/utils/mod.rs

@@ -1,8 +1,10 @@
+mod bytes;
 mod checked_sub;
 mod paths;
 mod pause;
 mod rlimit;
 
+pub use bytes::*;
 pub use checked_sub::*;
 pub use paths::*;
 pub use pause::*;