global: fixes + snapshot + packages

crates/brk_core/src/structs/difficultyepoch.rs

@@ -1,4 +1,7 @@
-use std::{fmt::Debug, ops::Add};
+use std::{
+    fmt::Debug,
+    ops::{Add, Div},
+};
 
 use serde::{Deserialize, Serialize};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
@@ -43,6 +46,14 @@ impl From<DifficultyEpoch> for usize {
     }
 }
 
+impl Add for DifficultyEpoch {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::from(self.0 + rhs.0)
+    }
+}
+
 impl Add<usize> for DifficultyEpoch {
     type Output = Self;
 
@@ -51,6 +62,13 @@ impl Add<usize> for DifficultyEpoch {
     }
 }
 
+impl Div<usize> for DifficultyEpoch {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self::from(self.0 as usize / rhs)
+    }
+}
+
 impl From<Height> for DifficultyEpoch {
     fn from(value: Height) -> Self {
         Self((u32::from(value) / 2016) as u16)

crates/brk_core/src/structs/halvingepoch.rs

@@ -1,4 +1,7 @@
-use std::{fmt::Debug, ops::Add};
+use std::{
+    fmt::Debug,
+    ops::{Add, Div},
+};
 
 use serde::{Deserialize, Serialize};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
@@ -43,6 +46,14 @@ impl From<HalvingEpoch> for usize {
     }
 }
 
+impl Add for HalvingEpoch {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::from(self.0 + rhs.0)
+    }
+}
+
 impl Add<usize> for HalvingEpoch {
     type Output = Self;
 
@@ -62,3 +73,10 @@ impl CheckedSub for HalvingEpoch {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
+
+impl Div<usize> for HalvingEpoch {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self::from(self.0 as usize / rhs)
+    }
+}

crates/brk_core/src/structs/mod.rs

@@ -24,6 +24,7 @@ mod outputtypeindex;
 mod quarterindex;
 mod rawlocktime;
 mod sats;
+mod stored_f64;
 mod stored_u32;
 mod stored_u64;
 mod stored_u8;
@@ -66,6 +67,7 @@ pub use outputtypeindex::*;
 pub use quarterindex::*;
 pub use rawlocktime::*;
 pub use sats::*;
+pub use stored_f64::*;
 pub use stored_u8::*;
 pub use stored_u32::*;
 pub use stored_u64::*;

crates/brk_core/src/structs/ohlc.rs

@@ -6,7 +6,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::{Cents, Dollars, Sats};
 
-#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize)]
+#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
 #[repr(C)]
 pub struct OHLCCents {
     pub open: Open<Cents>,
@@ -37,6 +37,20 @@ impl From<Close<Cents>> for OHLCCents {
     }
 }
 
+impl Serialize for OHLCCents {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut tup = serializer.serialize_tuple(4)?;
+        tup.serialize_element(&self.open)?;
+        tup.serialize_element(&self.high)?;
+        tup.serialize_element(&self.low)?;
+        tup.serialize_element(&self.close)?;
+        tup.end()
+    }
+}
+
 #[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
 #[repr(C)]
 pub struct OHLCDollars {

crates/brk_core/src/structs/stored_f64.rs

@@ -0,0 +1,69 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    PartialOrd,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct StoredF64(f64);
+
+impl From<f64> for StoredF64 {
+    fn from(value: f64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for StoredF64 {
+    fn from(value: usize) -> Self {
+        Self(value as f64)
+    }
+}
+
+impl CheckedSub<StoredF64> for StoredF64 {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        Some(Self(self.0 - rhs.0))
+    }
+}
+
+impl Div<usize> for StoredF64 {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs as f64)
+    }
+}
+
+impl Add for StoredF64 {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl From<StoredF64> for f64 {
+    fn from(value: StoredF64) -> Self {
+        value.0
+    }
+}
+
+impl Eq for StoredF64 {}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for StoredF64 {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.partial_cmp(&other.0).unwrap()
+    }
+}