global: from custom unsafe_slice to zerocopy

indexer/src/structs/addressbytes.rs

@@ -1,6 +1,7 @@
 use biter::bitcoin::ScriptBuf;
 use color_eyre::eyre::eyre;
 use derive_deref::{Deref, DerefMut};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Addresstype;
 
@@ -122,28 +123,28 @@ impl From<P2TRAddressBytes> for Addressbytes {
     }
 }
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2PK65AddressBytes(U8x65);
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2PK33AddressBytes(U8x33);
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2PKHAddressBytes(U8x20);
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2SHAddressBytes(U8x20);
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2WPKHAddressBytes(U8x20);
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2WSHAddressBytes(U8x32);
 
-#[derive(Debug, Clone, Deref, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct P2TRAddressBytes(U8x32);
 
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct U8x20([u8; 20]);
 impl From<&[u8]> for U8x20 {
     fn from(slice: &[u8]) -> Self {
@@ -153,7 +154,7 @@ impl From<&[u8]> for U8x20 {
     }
 }
 
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct U8x32([u8; 32]);
 impl From<&[u8]> for U8x32 {
     fn from(slice: &[u8]) -> Self {
@@ -163,7 +164,7 @@ impl From<&[u8]> for U8x32 {
     }
 }
 
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct U8x33([u8; 33]);
 impl From<&[u8]> for U8x33 {
     fn from(slice: &[u8]) -> Self {
@@ -173,7 +174,7 @@ impl From<&[u8]> for U8x33 {
     }
 }
 
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct U8x64([u8; 64]);
 impl From<&[u8]> for U8x64 {
     fn from(slice: &[u8]) -> Self {
@@ -183,7 +184,7 @@ impl From<&[u8]> for U8x64 {
     }
 }
 
-#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq)]
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct U8x65([u8; 65]);
 impl From<&[u8]> for U8x65 {
     fn from(slice: &[u8]) -> Self {

indexer/src/structs/addressindex.rs

@@ -2,9 +2,24 @@ use std::ops::Add;
 
 use derive_deref::{Deref, DerefMut};
 use fjall::Slice;
-use unsafe_slice_serde::UnsafeSliceSerde;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Deref, DerefMut, Default)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Addressindex(u32);
 
 impl Addressindex {
@@ -52,14 +67,14 @@ impl From<Addressindex> for usize {
 }
 
 impl TryFrom<Slice> for Addressindex {
-    type Error = unsafe_slice_serde::Error;
+    type Error = storable_vec::Error;
     fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
+        Ok(Self::read_from_bytes(&value)?)
     }
 }
 impl From<Addressindex> for Slice {
     fn from(value: Addressindex) -> Self {
-        Self::new(value.unsafe_as_slice())
+        Self::new(value.as_bytes())
     }
 }
 

indexer/src/structs/addresstype.rs

@@ -1,6 +1,8 @@
 use biter::bitcoin::ScriptBuf;
+use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, TryFromBytes, Immutable, IntoBytes, KnownLayout)]
+#[repr(u8)]
 pub enum Addresstype {
     P2PK65,
     P2PK33,

indexer/src/structs/addresstypeindex.rs

@@ -1,8 +1,24 @@
 use std::ops::Add;
 
 use derive_deref::{Deref, DerefMut};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Deref, DerefMut, Default)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Addresstypeindex(u32);
 
 impl Addresstypeindex {

indexer/src/structs/amount.rs

@@ -5,14 +5,30 @@ use std::{
 
 use biter::bitcoin;
 use derive_deref::{Deref, DerefMut};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Height;
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Deref, DerefMut, Default)]
-pub struct Amount(bitcoin::Amount);
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
+pub struct Amount(u64);
 
 impl Amount {
-    pub const ZERO: Self = Self(bitcoin::Amount::ZERO);
+    pub const ZERO: Self = Self(0);
     pub const ONE_BTC_F32: f32 = 100_000_000.0;
     pub const ONE_BTC_F64: f64 = 100_000_000.0;
 
@@ -24,65 +40,70 @@ impl Amount {
 impl Add for Amount {
     type Output = Amount;
     fn add(self, rhs: Amount) -> Self::Output {
-        Amount::from(self.to_sat() + rhs.to_sat())
+        Amount::from(*self + *rhs)
     }
 }
 
 impl AddAssign for Amount {
     fn add_assign(&mut self, rhs: Self) {
-        *self = Amount::from(self.to_sat() + rhs.to_sat());
+        *self = *self + rhs;
     }
 }
 
 impl Sub for Amount {
     type Output = Amount;
     fn sub(self, rhs: Amount) -> Self::Output {
-        Amount::from(self.to_sat() - rhs.to_sat())
+        Amount::from(*self - *rhs)
     }
 }
 
 impl SubAssign for Amount {
     fn sub_assign(&mut self, rhs: Self) {
-        *self = Amount::from(self.to_sat() - rhs.to_sat());
+        *self = *self - rhs;
     }
 }
 
 impl Mul<Amount> for Amount {
     type Output = Amount;
     fn mul(self, rhs: Amount) -> Self::Output {
-        Amount::from(self.to_sat() * rhs.to_sat())
+        Amount::from(*self * *rhs)
     }
 }
 
 impl Mul<u64> for Amount {
     type Output = Amount;
     fn mul(self, rhs: u64) -> Self::Output {
-        Amount::from(self.to_sat() * rhs)
+        Amount::from(*self * rhs)
     }
 }
 
 impl Mul<Height> for Amount {
     type Output = Amount;
     fn mul(self, rhs: Height) -> Self::Output {
-        Amount::from(self.to_sat() * *rhs as u64)
+        Amount::from(*self * *rhs as u64)
     }
 }
 
 impl Sum for Amount {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        let sats: u64 = iter.map(|amt| amt.to_sat()).sum();
+        let sats: u64 = iter.map(|amt| *amt).sum();
         Amount::from(sats)
     }
 }
 
 impl From<u64> for Amount {
     fn from(value: u64) -> Self {
-        Self(bitcoin::Amount::from_sat(value))
+        Self(value)
     }
 }
 
 impl From<bitcoin::Amount> for Amount {
     fn from(value: bitcoin::Amount) -> Self {
-        Self(value)
+        Self(value.to_sat())
+    }
+}
+impl From<Amount> for bitcoin::Amount {
+    fn from(value: Amount) -> Self {
+        Self::from_sat(value.0)
     }
 }

indexer/src/structs/blockhash.rs

@@ -0,0 +1,19 @@
+use std::mem;
+
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
+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) }
+    }
+}

indexer/src/structs/compressed.rs

@@ -1,13 +1,12 @@
 use std::hash::Hasher;
 
-use biter::bitcoin::{BlockHash, Txid};
 use derive_deref::Deref;
 use fjall::Slice;
-use unsafe_slice_serde::UnsafeSliceSerde;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use super::{Addressbytes, Addresstype, SliceExtended};
+use super::{Addressbytes, Addresstype, BlockHash, Txid};
 
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[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 {
@@ -24,14 +23,14 @@ impl From<[u8; 8]> for AddressHash {
     }
 }
 impl TryFrom<Slice> for AddressHash {
-    type Error = color_eyre::Report;
+    type Error = storable_vec::Error;
     fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
+        Ok(Self::read_from_bytes(&value)?)
     }
 }
 impl From<&AddressHash> for Slice {
     fn from(value: &AddressHash) -> Self {
-        Self::new(value.unsafe_as_slice())
+        Self::new(value.as_bytes())
     }
 }
 impl From<AddressHash> for Slice {
@@ -40,23 +39,23 @@ impl From<AddressHash> for Slice {
     }
 }
 
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout)]
 pub struct BlockHashPrefix([u8; 8]);
 impl TryFrom<&BlockHash> for BlockHashPrefix {
     type Error = color_eyre::Report;
     fn try_from(value: &BlockHash) -> Result<Self, Self::Error> {
-        Ok(Self((&value[..]).read_8x_u8()?))
+        Ok(Self(copy_first_8bytes(&value[..])))
     }
 }
 impl TryFrom<Slice> for BlockHashPrefix {
-    type Error = color_eyre::Report;
+    type Error = storable_vec::Error;
     fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
+        Ok(Self::read_from_bytes(&value)?)
     }
 }
 impl From<&BlockHashPrefix> for Slice {
     fn from(value: &BlockHashPrefix) -> Self {
-        Self::new(value.unsafe_as_slice())
+        Self::new(value.as_bytes())
     }
 }
 impl From<BlockHashPrefix> for Slice {
@@ -65,23 +64,23 @@ impl From<BlockHashPrefix> for Slice {
     }
 }
 
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout)]
 pub struct TxidPrefix([u8; 8]);
 impl TryFrom<&Txid> for TxidPrefix {
     type Error = color_eyre::Report;
     fn try_from(value: &Txid) -> Result<Self, Self::Error> {
-        Ok(Self((&value[..]).read_8x_u8()?))
+        Ok(Self(copy_first_8bytes(&value[..])))
     }
 }
 impl TryFrom<Slice> for TxidPrefix {
-    type Error = color_eyre::Report;
+    type Error = storable_vec::Error;
     fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
+        Ok(Self::read_from_bytes(&value)?)
     }
 }
 impl From<&TxidPrefix> for Slice {
     fn from(value: &TxidPrefix) -> Self {
-        Self::new(value.unsafe_as_slice())
+        Self::new(value.as_bytes())
     }
 }
 impl From<TxidPrefix> for Slice {
@@ -89,3 +88,15 @@ impl From<TxidPrefix> for Slice {
         Self::from(&value)
     }
 }
+
+fn copy_first_8bytes(slice: &[u8]) -> [u8; 8] {
+    let mut buf: [u8; 8] = [0; 8];
+    let buf_len = buf.len();
+    if slice.len() < buf_len {
+        panic!("bad len");
+    }
+    slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
+        buf[i] = *r;
+    });
+    buf
+}

indexer/src/structs/height.rs

@@ -7,14 +7,29 @@ use std::{
 use biter::rpc::{self, RpcApi};
 use derive_deref::{Deref, DerefMut};
 use fjall::Slice;
-use unsafe_slice_serde::UnsafeSliceSerde;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, Clone, Copy, Deref, DerefMut, PartialEq, Eq, PartialOrd, Ord, Default)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Height(u32);
 
 impl Height {
     pub fn write(&self, path: &Path) -> Result<(), io::Error> {
-        fs::write(path, self.unsafe_as_slice())
+        fs::write(path, self.as_bytes())
     }
 }
 
@@ -113,9 +128,9 @@ impl From<Height> for usize {
 }
 
 impl TryFrom<&Path> for Height {
-    type Error = color_eyre::Report;
+    type Error = storable_vec::Error;
     fn try_from(value: &Path) -> Result<Self, Self::Error> {
-        Ok(Self::unsafe_try_from_slice(fs::read(value)?.as_slice())?.to_owned())
+        Ok(Self::read_from_bytes(fs::read(value)?.as_slice())?.to_owned())
     }
 }
 
@@ -127,13 +142,25 @@ impl TryFrom<&rpc::Client> for Height {
 }
 
 impl TryFrom<Slice> for Height {
-    type Error = unsafe_slice_serde::Error;
+    type Error = storable_vec::Error;
     fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
+        Ok(Self::read_from_bytes(&value)?)
     }
 }
 impl From<Height> for Slice {
     fn from(value: Height) -> Self {
-        Self::new(value.unsafe_as_slice())
+        Self::new(value.as_bytes())
+    }
+}
+
+impl From<bitcoin::locktime::absolute::Height> for Height {
+    fn from(value: bitcoin::locktime::absolute::Height) -> Self {
+        Self(value.to_consensus_u32())
+    }
+}
+
+impl From<Height> for bitcoin::locktime::absolute::Height {
+    fn from(value: Height) -> Self {
+        bitcoin::locktime::absolute::Height::from_consensus(*value).unwrap()
     }
 }

indexer/src/structs/locktime.rs

@@ -0,0 +1,28 @@
+use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+
+use super::{Height, Timestamp};
+
+#[derive(Debug, Immutable, Clone, Copy, IntoBytes, KnownLayout, TryFromBytes)]
+#[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()),
+        }
+    }
+}

indexer/src/structs/mod.rs

@@ -3,29 +3,35 @@ mod addressindex;
 mod addresstype;
 mod addresstypeindex;
 mod amount;
+mod blockhash;
 mod compressed;
 mod height;
-mod slice;
+mod locktime;
 mod timestamp;
+mod txid;
 mod txindex;
 mod txinindex;
 mod txoutindex;
-mod version;
+mod txversion;
 mod vin;
 mod vout;
+mod weight;
 
 pub use addressbytes::*;
 pub use addressindex::*;
 pub use addresstype::*;
 pub use addresstypeindex::*;
 pub use amount::*;
+pub use blockhash::*;
 pub use compressed::*;
 pub use height::*;
-pub use slice::*;
+pub use locktime::*;
 pub use timestamp::*;
+pub use txid::*;
 pub use txindex::*;
 pub use txinindex::*;
 pub use txoutindex::*;
-pub use version::*;
+pub use txversion::*;
 pub use vin::*;
 pub use vout::*;
+pub use weight::*;

indexer/src/structs/slice.rs

@@ -1,55 +0,0 @@
-use color_eyre::eyre::eyre;
-
-#[allow(unused)]
-pub trait SliceExtended {
-    fn read_8x_u8(&self) -> color_eyre::Result<[u8; 8]>;
-    fn read_be_u8(&self) -> color_eyre::Result<u8>;
-    fn read_be_u16(&self) -> color_eyre::Result<u16>;
-    fn read_be_u32(&self) -> color_eyre::Result<u32>;
-    fn read_be_u64(&self) -> color_eyre::Result<u64>;
-    fn read_exact(&self, buf: &mut [u8]) -> color_eyre::Result<()>;
-}
-
-impl SliceExtended for &[u8] {
-    fn read_8x_u8(&self) -> color_eyre::Result<[u8; 8]> {
-        let mut buf: [u8; 8] = [0; 8];
-        (&self[..8]).read_exact(&mut buf)?;
-        Ok(buf)
-    }
-
-    fn read_be_u8(&self) -> color_eyre::Result<u8> {
-        let mut buf: [u8; 1] = [0; 1];
-        self.read_exact(&mut buf)?;
-        Ok(u8::from_be_bytes(buf))
-    }
-
-    fn read_be_u16(&self) -> color_eyre::Result<u16> {
-        let mut buf: [u8; 2] = [0; 2];
-        self.read_exact(&mut buf)?;
-        Ok(u16::from_be_bytes(buf))
-    }
-
-    fn read_be_u32(&self) -> color_eyre::Result<u32> {
-        let mut buf: [u8; 4] = [0; 4];
-        self.read_exact(&mut buf)?;
-        Ok(u32::from_be_bytes(buf))
-    }
-
-    fn read_be_u64(&self) -> color_eyre::Result<u64> {
-        let mut buf: [u8; 8] = [0; 8];
-        self.read_exact(&mut buf)?;
-        Ok(u64::from_be_bytes(buf))
-    }
-
-    fn read_exact(&self, buf: &mut [u8]) -> color_eyre::Result<()> {
-        let buf_len = buf.len();
-        if self.len() != buf_len {
-            dbg!(self.len(), buf_len);
-            return Err(eyre!("Not exact len"));
-        }
-        self.iter().take(buf_len).enumerate().for_each(|(i, r)| {
-            buf[i] = *r;
-        });
-        Ok(())
-    }
-}

indexer/src/structs/timestamp.rs

@@ -1,11 +1,29 @@
 use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Timestamp(jiff::Timestamp);
+#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout)]
+pub struct Timestamp(u32);
 
-impl TryFrom<u32> for Timestamp {
-    type Error = jiff::Error;
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
-        Ok(Self(jiff::Timestamp::from_second(value as i64)?))
+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()
     }
 }

indexer/src/structs/txid.rs

@@ -0,0 +1,19 @@
+use std::mem;
+
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
+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) }
+    }
+}

indexer/src/structs/txindex.rs

@@ -2,9 +2,24 @@ use std::ops::{Add, AddAssign, Sub};
 
 use derive_deref::{Deref, DerefMut};
 use fjall::Slice;
-use unsafe_slice_serde::UnsafeSliceSerde;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Deref, DerefMut, Default)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Txindex(u32);
 
 impl Txindex {
@@ -73,13 +88,13 @@ impl From<Txindex> for usize {
 }
 
 impl TryFrom<Slice> for Txindex {
-    type Error = unsafe_slice_serde::Error;
+    type Error = storable_vec::Error;
     fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
+        Ok(Self::read_from_bytes(&value)?)
     }
 }
 impl From<Txindex> for Slice {
     fn from(value: Txindex) -> Self {
-        Self::new(value.unsafe_as_slice())
+        Self::new(value.as_bytes())
     }
 }

indexer/src/structs/txinindex.rs

@@ -1,10 +1,26 @@
 use std::ops::{Add, AddAssign, Sub};
 
 use derive_deref::{Deref, DerefMut};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Vin;
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Deref, DerefMut, Default)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Txinindex(u64);
 
 impl Txinindex {

indexer/src/structs/txoutindex.rs

@@ -1,10 +1,26 @@
 use std::ops::{Add, AddAssign, Sub};
 
 use derive_deref::{Deref, DerefMut};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Vout;
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Deref, DerefMut, Default)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Txoutindex(u64);
 
 impl Txoutindex {

indexer/src/structs/txversion.rs

@@ -0,0 +1,17 @@
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes)]
+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)
+    }
+}

indexer/src/structs/version.rs

@@ -1,38 +0,0 @@
-use std::{fs, io, path::Path};
-
-use fjall::Slice;
-use unsafe_slice_serde::UnsafeSliceSerde;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Version(u32);
-
-impl Version {
-    pub fn write(&self, path: &Path) -> Result<(), io::Error> {
-        fs::write(path, self.unsafe_as_slice())
-    }
-}
-
-impl From<u32> for Version {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl TryFrom<&Path> for Version {
-    type Error = color_eyre::Report;
-    fn try_from(value: &Path) -> Result<Self, Self::Error> {
-        Ok(Self::unsafe_try_from_slice(fs::read(value)?.as_slice())?.to_owned())
-    }
-}
-
-impl TryFrom<Slice> for Version {
-    type Error = color_eyre::Report;
-    fn try_from(value: Slice) -> Result<Self, Self::Error> {
-        Ok(*Self::unsafe_try_from_slice(&value)?)
-    }
-}
-impl From<Version> for Slice {
-    fn from(value: Version) -> Self {
-        Self::new(value.unsafe_as_slice())
-    }
-}

indexer/src/structs/weight.rs

@@ -0,0 +1,17 @@
+use derive_deref::Deref;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes)]
+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)
+    }
+}