global: chain + cointime datasets

crates/brk_structs/src/structs/date.rs

@@ -1,8 +1,10 @@
-use jiff::{Span, civil::Date as Date_, tz::TimeZone};
+use jiff::{Span, Zoned, civil::Date as Date_, tz::TimeZone};
 use serde::{Serialize, Serializer};
 use vecdb::StoredCompressed;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
+use crate::ONE_DAY_IN_SEC_F64;
+
 use super::{DateIndex, Timestamp};
 
 #[derive(
@@ -51,6 +53,21 @@ impl Date {
     pub fn today() -> Self {
         Self::from(Timestamp::now())
     }
+
+    pub fn completion(&self) -> f64 {
+        let date = Date_::from(*self);
+        let now = Zoned::now().with_time_zone(TimeZone::UTC);
+        let today = now.date();
+
+        if date < today {
+            1.0
+        } else if date == today {
+            let rounded = jiff::Timestamp::from(*self);
+            now.timestamp().duration_since(rounded).as_secs_f64() / ONE_DAY_IN_SEC_F64
+        } else {
+            0.0
+        }
+    }
 }
 
 impl Default for Date {
@@ -71,6 +88,12 @@ impl From<Date> for Date_ {
     }
 }
 
+impl From<Date> for jiff::Timestamp {
+    fn from(value: Date) -> Self {
+        Self::from(Timestamp::from(value))
+    }
+}
+
 impl From<Timestamp> for Date {
     fn from(value: Timestamp) -> Self {
         Self::from(Date_::from(

crates/brk_structs/src/structs/ohlc.rs

@@ -9,6 +9,8 @@ use serde::{Serialize, Serializer, ser::SerializeTuple};
 use vecdb::StoredCompressed;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
+use crate::StoredF64;
+
 use super::{Cents, Dollars, Sats};
 
 #[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
@@ -217,6 +219,15 @@ where
     }
 }
 
+impl<T> From<Open<T>> for StoredF64
+where
+    StoredF64: From<T>,
+{
+    fn from(value: Open<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl<T> From<Close<T>> for Open<T>
 where
     T: Copy,
@@ -315,6 +326,15 @@ where
     }
 }
 
+impl<T> From<High<T>> for StoredF64
+where
+    StoredF64: From<T>,
+{
+    fn from(value: High<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl<T> From<Close<T>> for High<T>
 where
     T: Copy,
@@ -413,6 +433,15 @@ where
     }
 }
 
+impl<T> From<Low<T>> for StoredF64
+where
+    StoredF64: From<T>,
+{
+    fn from(value: Low<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl<T> From<Close<T>> for Low<T>
 where
     T: Copy,
@@ -530,6 +559,15 @@ where
     }
 }
 
+impl<T> From<Close<T>> for StoredF64
+where
+    StoredF64: From<T>,
+{
+    fn from(value: Close<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 // impl<A, B> From<Close<A>> for Close<B>
 // where
 //     B: From<A>,

crates/brk_structs/src/structs/stored_f32.rs

@@ -153,6 +153,13 @@ impl Mul<usize> for StoredF32 {
     }
 }
 
+impl Mul<StoredF32> for StoredF32 {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
 impl Mul<StoredF32> for usize {
     type Output = StoredF32;
     fn mul(self, rhs: StoredF32) -> Self::Output {

crates/brk_structs/src/structs/stored_f64.rs

@@ -64,6 +64,20 @@ impl Mul<usize> for StoredF64 {
     }
 }
 
+impl Mul<StoredF64> for StoredF64 {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
+impl Mul<Dollars> for StoredF64 {
+    type Output = Self;
+    fn mul(self, rhs: Dollars) -> Self::Output {
+        Self(self.0 * *rhs)
+    }
+}
+
 impl Div<usize> for StoredF64 {
     type Output = Self;
     fn div(self, rhs: usize) -> Self::Output {

crates/brk_structs/src/structs/timestamp.rs

@@ -28,9 +28,9 @@ use super::Date;
 )]
 pub struct Timestamp(u32);
 
-const ONE_HOUR_IN_SEC: u32 = 60 * 60;
-const ONE_DAY_IN_SEC: u32 = 24 * 60 * 60;
-const ONE_DAY_IN_SEC_F64: f64 = ONE_DAY_IN_SEC as f64;
+pub const ONE_HOUR_IN_SEC: u32 = 60 * 60;
+pub const ONE_DAY_IN_SEC: u32 = 24 * 60 * 60;
+pub const ONE_DAY_IN_SEC_F64: f64 = ONE_DAY_IN_SEC as f64;
 
 impl Timestamp {
     pub const ZERO: Self = Self(0);
@@ -75,14 +75,6 @@ impl Timestamp {
     pub fn now() -> Self {
         Self::from(jiff::Timestamp::now())
     }
-
-    pub fn day_completion(&self) -> f64 {
-        let rounded = jiff::Timestamp::from(Self::from(Date::from(*self)));
-        ONE_DAY_IN_SEC_F64
-            / jiff::Timestamp::from(*self)
-                .duration_since(rounded)
-                .as_secs_f64()
-    }
 }
 
 impl From<u32> for Timestamp {