global: wip

crates/brk_core/Cargo.toml

@@ -11,6 +11,7 @@ bitcoin = { workspace = true }
 bitcoincore-rpc = { workspace = true }
 byteview = { workspace = true }
 derive_deref = { workspace = true }
+fjall = { workspace = true }
 jiff = { workspace = true }
 log = { workspace = true }
 rapidhash = "1.4.0"
@@ -19,6 +20,7 @@ serde = { workspace = true }
 serde_bytes = "0.11.17"
 serde_derive = { workspace = true }
 serde_json = { workspace = true }
+thiserror = "2.0.12"
 zerocopy = { workspace = true }
 zerocopy-derive = { workspace = true }
 

crates/brk_core/src/enums/error.rs

@@ -1,20 +1,24 @@
 use std::{
     fmt::{self, Debug},
-    io,
-    time::SystemTimeError,
+    io, result, time,
 };
 
 use crate::Version;
 
-pub type Result<T, E = Error> = std::result::Result<T, E>;
+pub type Result<T, E = Error> = result::Result<T, E>;
 
 #[derive(Debug)]
 pub enum Error {
+    IO(io::Error),
+    SerdeJson(serde_json::Error),
+    Jiff(jiff::Error),
+    Fjall(fjall::Error),
+    SystemTimeError(time::SystemTimeError),
+    ZeroCopyError,
+
     WrongEndian,
     DifferentVersion { found: Version, expected: Version },
     MmapsVecIsTooSmall,
-    IO(io::Error),
-    ZeroCopyError,
     IndexTooHigh,
     EmptyVec,
     IndexTooLow,
@@ -24,17 +28,16 @@ pub enum Error {
     UnsupportedUnflushedState,
     RangeFromAfterTo(usize, usize),
     DifferentCompressionMode,
-    SystemTimeError,
-    ToSerdeJsonValueError(serde_json::Error),
-    Jiff(jiff::Error),
     WrongLength,
     WrongAddressType,
     UnindexableDate,
+
+    String(&'static str),
 }
 
-impl From<SystemTimeError> for Error {
-    fn from(_: SystemTimeError) -> Self {
-        Self::SystemTimeError
+impl From<time::SystemTimeError> for Error {
+    fn from(value: time::SystemTimeError) -> Self {
+        Self::SystemTimeError(value)
     }
 }
 
@@ -50,6 +53,12 @@ impl From<jiff::Error> for Error {
     }
 }
 
+impl From<fjall::Error> for Error {
+    fn from(value: fjall::Error) -> Self {
+        Self::Fjall(value)
+    }
+}
+
 impl<A, B, C> From<zerocopy::error::ConvertError<A, B, C>> for Error {
     fn from(_: zerocopy::error::ConvertError<A, B, C>) -> Self {
         Self::ZeroCopyError
@@ -64,13 +73,20 @@ impl<A, B> From<zerocopy::error::SizeError<A, B>> for Error {
 
 impl From<serde_json::Error> for Error {
     fn from(error: serde_json::Error) -> Self {
-        Self::ToSerdeJsonValueError(error)
+        Self::SerdeJson(error)
     }
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            Error::IO(error) => Debug::fmt(&error, f),
+            Error::SystemTimeError(error) => Debug::fmt(&error, f),
+            Error::SerdeJson(error) => Debug::fmt(&error, f),
+            Error::Jiff(error) => Debug::fmt(&error, f),
+            Error::Fjall(error) => Debug::fmt(&error, f),
+            Error::ZeroCopyError => write!(f, "ZeroCopy error"),
+
             Error::WrongEndian => write!(f, "Wrong endian"),
             Error::DifferentVersion { found, expected } => {
                 write!(
@@ -79,7 +95,6 @@ impl fmt::Display for Error {
                 )
             }
             Error::MmapsVecIsTooSmall => write!(f, "Mmaps vec is too small"),
-            Error::IO(error) => Debug::fmt(&error, f),
             Error::IndexTooHigh => write!(f, "Index too high"),
             Error::IndexTooLow => write!(f, "Index too low"),
             Error::ExpectFileToHaveIndex => write!(f, "Expect file to have index"),
@@ -91,19 +106,17 @@ impl fmt::Display for Error {
                     "Unsupported unflush state, please flush before using this function"
                 )
             }
-            Error::ZeroCopyError => write!(f, "Zero copy convert error"),
-            Error::SystemTimeError => write!(f, "SystemTimeError"),
             Error::RangeFromAfterTo(from, to) => write!(f, "Range, from {from} is after to {to}"),
             Error::DifferentCompressionMode => write!(f, "Different compression mode chosen"),
             Error::EmptyVec => write!(f, "The Vec is empty, maybe wait for a bit"),
-            Error::ToSerdeJsonValueError(error) => Debug::fmt(&error, f),
-            Error::Jiff(error) => Debug::fmt(&error, f),
             Error::WrongLength => write!(f, "Wrong length"),
             Error::WrongAddressType => write!(f, "Wrong address type"),
             Error::UnindexableDate => write!(
                 f,
                 "Date cannot be indexed, must be 2009-01-03, 2009-01-09 or greater"
             ),
+
+            Error::String(s) => write!(f, "{s}"),
         }
     }
 }

crates/brk_core/src/structs/dollars.rs

@@ -4,11 +4,12 @@ use std::{
     ops::{Add, AddAssign, Div, Mul},
 };
 
+use byteview::ByteView;
 use derive_deref::Deref;
 use serde::Serialize;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use crate::CheckedSub;
+use crate::{CheckedSub, Error, copy_first_8bytes};
 
 use super::{Bitcoin, Cents, Close, Sats, StoredF32, StoredF64};
 
@@ -133,12 +134,18 @@ impl Div<Bitcoin> for Dollars {
 impl Mul<Bitcoin> for Dollars {
     type Output = Self;
     fn mul(self, rhs: Bitcoin) -> Self::Output {
+        self * Sats::from(rhs)
+    }
+}
+
+impl Mul<Sats> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: Sats) -> Self::Output {
         if self.is_nan() {
             self
         } else {
             Self::from(Cents::from(
-                u128::from(Sats::from(rhs)) * u128::from(Cents::from(self))
-                    / u128::from(Sats::ONE_BTC),
+                u128::from(rhs) * u128::from(Cents::from(self)) / u128::from(Sats::ONE_BTC),
             ))
         }
     }
@@ -248,3 +255,23 @@ impl Ord for Dollars {
         }
     }
 }
+
+impl TryFrom<ByteView> for Dollars {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        let bytes = copy_first_8bytes(&value)?;
+        Ok(Self::from(f64::from_be_bytes(bytes)))
+    }
+}
+
+impl From<Dollars> for ByteView {
+    fn from(value: Dollars) -> Self {
+        Self::from(&value)
+    }
+}
+
+impl From<&Dollars> for ByteView {
+    fn from(value: &Dollars) -> Self {
+        Self::new(&value.to_be_bytes())
+    }
+}

crates/brk_core/src/structs/sats.rs

@@ -4,10 +4,11 @@ use std::{
 };
 
 use bitcoin::Amount;
+use byteview::ByteView;
 use serde::Serialize;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use crate::CheckedSub;
+use crate::{CheckedSub, Error, copy_first_8bytes};
 
 use super::{Bitcoin, Cents, Dollars, Height};
 
@@ -187,3 +188,23 @@ impl From<Sats> for u128 {
         value.0 as u128
     }
 }
+
+impl TryFrom<ByteView> for Sats {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        let bytes = copy_first_8bytes(&value)?;
+        Ok(Self::from(u64::from_be_bytes(bytes)))
+    }
+}
+
+impl From<&Sats> for ByteView {
+    fn from(value: &Sats) -> Self {
+        Self::new(&value.0.to_be_bytes())
+    }
+}
+
+impl From<Sats> for ByteView {
+    fn from(value: Sats) -> Self {
+        Self::from(&value)
+    }
+}

crates/brk_core/src/utils/bytes.rs

@@ -1,9 +1,11 @@
+use crate::{Error, Result};
+
 #[allow(clippy::result_unit_err)]
-pub fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8], ()> {
+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(());
+        return Err(Error::String("Buffer is too small to convert to 8 bytes"));
     }
     slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
         buf[i] = *r;