computer: store part 6

crates/brk_computer/src/states/block.rs

@@ -0,0 +1,32 @@
+use std::ops::{Add, AddAssign, SubAssign};
+
+use brk_core::{Dollars, Timestamp};
+
+use super::SupplyState;
+
+#[derive(Debug, Clone)]
+pub struct BlockState {
+    pub supply: SupplyState,
+    pub price: Option<Dollars>,
+    pub timestamp: Timestamp,
+}
+
+impl Add<BlockState> for BlockState {
+    type Output = Self;
+    fn add(mut self, rhs: BlockState) -> Self::Output {
+        self.supply += &rhs.supply;
+        self
+    }
+}
+
+impl AddAssign<&BlockState> for BlockState {
+    fn add_assign(&mut self, rhs: &Self) {
+        self.supply += &rhs.supply;
+    }
+}
+
+impl SubAssign<&BlockState> for BlockState {
+    fn sub_assign(&mut self, rhs: &Self) {
+        self.supply -= &rhs.supply;
+    }
+}

crates/brk_computer/src/states/cohorts/address.rs

@@ -0,0 +1,101 @@
+use std::path::Path;
+
+use brk_core::{AddressData, Dollars, Height, Result, Sats};
+
+use crate::SupplyState;
+
+use super::CohortState;
+
+#[derive(Clone)]
+pub struct AddressCohortState {
+    pub address_count: usize,
+    pub inner: CohortState,
+}
+
+impl AddressCohortState {
+    pub fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+        Ok(Self {
+            address_count: 0,
+            inner: CohortState::default_and_import(path, name, compute_dollars)?,
+        })
+    }
+
+    pub fn reset_single_iteration_values(&mut self) {
+        self.inner.reset_single_iteration_values();
+    }
+
+    pub fn send(
+        &mut self,
+        value: Sats,
+        current_price: Option<Dollars>,
+        prev_price: Option<Dollars>,
+        blocks_old: usize,
+        days_old: f64,
+        older_than_hour: bool,
+    ) {
+        self.inner.send(
+            &SupplyState { utxos: 1, value },
+            current_price,
+            prev_price,
+            blocks_old,
+            days_old,
+            older_than_hour,
+        );
+    }
+
+    pub fn receive(&mut self, value: Sats, price: Option<Dollars>) {
+        self.inner.receive(&SupplyState { utxos: 1, value }, price);
+    }
+
+    pub fn add(&mut self, addressdata: &AddressData) {
+        self.address_count += 1;
+        self.inner
+            .increment_(&addressdata.into(), addressdata.realized_cap);
+    }
+
+    pub fn subtract(&mut self, addressdata: &AddressData) {
+        self.address_count.checked_sub(1).unwrap();
+        self.inner
+            .decrement_(&addressdata.into(), addressdata.realized_cap);
+    }
+
+    pub fn commit(&mut self, height: Height) -> Result<()> {
+        self.inner.commit(height)
+    }
+}
+
+//     fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+//         self.inner.decrement(supply_state, price);
+//     }
+
+//     fn decrement_price_to_amount(&mut self, supply_state: &SupplyState, price: Dollars) {
+//         self.inner.decrement_price_to_amount(supply_state, price);
+//     }
+
+//     fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+//         self.inner.receive(supply_state, price);
+//     }
+
+//     fn compute_unrealized_states(
+//         &self,
+//         height_price: Dollars,
+//         date_price: Option<Dollars>,
+//     ) -> (UnrealizedState, Option<UnrealizedState>) {
+//         self.inner
+//             .compute_unrealized_states(height_price, date_price)
+//     }
+
+// }
+
+// impl Deref for AddressCohortState {
+//     type Target = CohortState;
+//     fn deref(&self) -> &Self::Target {
+//         &self.inner
+//     }
+// }
+
+// impl DerefMut for AddressCohortState {
+//     fn deref_mut(&mut self) -> &mut Self::Target {
+//         &mut self.inner
+//     }
+// }

crates/brk_computer/src/states/cohorts/common.rs

@@ -0,0 +1,202 @@
+use std::{cmp::Ordering, path::Path};
+
+use brk_core::{Bitcoin, CheckedSub, Dollars, Height, Result, Sats};
+
+use crate::{PriceToAmount, RealizedState, SupplyState, UnrealizedState};
+
+#[derive(Clone)]
+pub struct CohortState {
+    pub supply: SupplyState,
+    pub realized: Option<RealizedState>,
+    pub satblocks_destroyed: Sats,
+    pub satdays_destroyed: Sats,
+    pub price_to_amount: PriceToAmount,
+}
+
+impl CohortState {
+    pub fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+        Ok(Self {
+            supply: SupplyState::default(),
+            realized: compute_dollars.then_some(RealizedState::NAN),
+            satblocks_destroyed: Sats::ZERO,
+            satdays_destroyed: Sats::ZERO,
+            price_to_amount: PriceToAmount::forced_import(path, name),
+        })
+    }
+
+    pub fn reset_single_iteration_values(&mut self) {
+        self.satdays_destroyed = Sats::ZERO;
+        self.satblocks_destroyed = Sats::ZERO;
+        if let Some(realized) = self.realized.as_mut() {
+            realized.reset_single_iteration_values();
+        }
+    }
+
+    pub fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.supply += supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                let price = price.unwrap();
+                realized.increment(supply_state, price);
+                *self.price_to_amount.entry(price).or_default() += supply_state.value;
+            }
+        }
+    }
+
+    pub fn increment_(&mut self, supply_state: &SupplyState, realized_cap: Dollars) {
+        self.supply += supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                realized.increment_(realized_cap);
+                *self
+                    .price_to_amount
+                    .entry(realized_cap / Bitcoin::from(supply_state.value))
+                    .or_default() += supply_state.value;
+            }
+        }
+    }
+
+    pub fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.supply -= supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                let price = price.unwrap();
+                realized.decrement(supply_state, price);
+                self.decrement_price_to_amount(supply_state, price);
+            }
+        }
+    }
+
+    pub fn decrement_(&mut self, supply_state: &SupplyState, realized_cap: Dollars) {
+        self.supply -= supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                realized.decrement_(realized_cap);
+                self.decrement_price_to_amount(
+                    supply_state,
+                    realized_cap / Bitcoin::from(supply_state.value),
+                );
+            }
+        }
+    }
+
+    fn decrement_price_to_amount(&mut self, supply_state: &SupplyState, price: Dollars) {
+        let amount = self.price_to_amount.get_mut(&price).unwrap();
+        *amount -= supply_state.value;
+        if *amount == Sats::ZERO {
+            self.price_to_amount.remove(&price);
+        }
+    }
+
+    pub fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.supply += supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                let price = price.unwrap();
+                realized.receive(supply_state, price);
+                *self.price_to_amount.entry(price).or_default() += supply_state.value;
+            }
+        }
+    }
+
+    pub fn send(
+        &mut self,
+        supply_state: &SupplyState,
+        current_price: Option<Dollars>,
+        prev_price: Option<Dollars>,
+        blocks_old: usize,
+        days_old: f64,
+        older_than_hour: bool,
+    ) {
+        if supply_state.utxos == 0 {
+            return;
+        }
+
+        self.supply -= supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            self.satblocks_destroyed += supply_state.value * blocks_old;
+
+            self.satdays_destroyed +=
+                Sats::from((u64::from(supply_state.value) as f64 * days_old).floor() as u64);
+
+            if let Some(realized) = self.realized.as_mut() {
+                let current_price = current_price.unwrap();
+                let prev_price = prev_price.unwrap();
+                realized.send(supply_state, current_price, prev_price, older_than_hour);
+                self.decrement_price_to_amount(supply_state, prev_price);
+            }
+        }
+    }
+
+    pub fn compute_unrealized_states(
+        &self,
+        height_price: Dollars,
+        date_price: Option<Dollars>,
+    ) -> (UnrealizedState, Option<UnrealizedState>) {
+        if self.price_to_amount.is_empty() {
+            return (
+                UnrealizedState::NAN,
+                date_price.map(|_| UnrealizedState::NAN),
+            );
+        }
+
+        let mut height_unrealized_state = UnrealizedState::ZERO;
+        let mut date_unrealized_state = date_price.map(|_| UnrealizedState::ZERO);
+
+        let update_state =
+            |price: Dollars, current_price: Dollars, sats: Sats, state: &mut UnrealizedState| {
+                match price.cmp(&current_price) {
+                    Ordering::Equal => {
+                        state.supply_even += sats;
+                    }
+                    Ordering::Less => {
+                        state.supply_in_profit += sats;
+                        if price > Dollars::ZERO && current_price > Dollars::ZERO {
+                            let diff = current_price.checked_sub(price).unwrap();
+                            if diff <= Dollars::ZERO {
+                                dbg!(price, current_price, diff, sats);
+                                panic!();
+                            }
+                            state.unrealized_profit += diff * sats;
+                        }
+                    }
+                    Ordering::Greater => {
+                        state.supply_in_loss += sats;
+                        if price > Dollars::ZERO && current_price > Dollars::ZERO {
+                            let diff = price.checked_sub(current_price).unwrap();
+                            if diff <= Dollars::ZERO {
+                                dbg!(price, current_price, diff, sats);
+                                panic!();
+                            }
+                            state.unrealized_loss += diff * sats;
+                        }
+                    }
+                }
+            };
+
+        self.price_to_amount.iter().for_each(|(&price, &sats)| {
+            update_state(price, height_price, sats, &mut height_unrealized_state);
+
+            if let Some(date_price) = date_price {
+                update_state(
+                    price,
+                    date_price,
+                    sats,
+                    date_unrealized_state.as_mut().unwrap(),
+                )
+            }
+        });
+
+        (height_unrealized_state, date_unrealized_state)
+    }
+
+    pub fn commit(&mut self, height: Height) -> Result<()> {
+        self.price_to_amount.flush(height)
+    }
+}

crates/brk_computer/src/states/cohorts/mod.rs

@@ -0,0 +1,7 @@
+mod address;
+mod common;
+mod utxo;
+
+pub use address::*;
+pub use common::*;
+pub use utxo::*;

crates/brk_computer/src/states/cohorts/utxo.rs

@@ -0,0 +1,19 @@
+use std::path::Path;
+
+use brk_core::Result;
+use derive_deref::{Deref, DerefMut};
+
+use super::CohortState;
+
+#[derive(Clone, Deref, DerefMut)]
+pub struct UTXOCohortState(CohortState);
+
+impl UTXOCohortState {
+    pub fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+        Ok(Self(CohortState::default_and_import(
+            path,
+            name,
+            compute_dollars,
+        )?))
+    }
+}

crates/brk_computer/src/states/mod.rs

@@ -0,0 +1,15 @@
+mod block;
+mod cohorts;
+mod price_to_amount;
+mod realized;
+mod supply;
+mod transacted;
+mod unrealized;
+
+pub use block::*;
+pub use cohorts::*;
+pub use price_to_amount::*;
+pub use realized::*;
+pub use supply::*;
+pub use transacted::*;
+pub use unrealized::*;

crates/brk_computer/src/states/price_to_amount.rs

@@ -0,0 +1,104 @@
+use std::{
+    collections::BTreeMap,
+    fs::{self, File},
+    io::{BufReader, BufWriter},
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+};
+
+use bincode::{Decode, Encode, config, decode_from_std_read, encode_into_std_write};
+use brk_core::{Dollars, Height, Result, Sats};
+use derive_deref::{Deref, DerefMut};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug)]
+pub struct PriceToAmount {
+    pathbuf: PathBuf,
+    height: Option<Height>,
+    state: State,
+}
+
+#[derive(Clone, Default, Debug, Deref, DerefMut, Serialize, Deserialize, Encode, Decode)]
+struct State(BTreeMap<Dollars, Sats>);
+
+impl PriceToAmount {
+    pub fn forced_import(path: &Path, name: &str) -> Self {
+        Self::import(path, name).unwrap_or_else(|_| Self {
+            pathbuf: Self::path_(path, name),
+            height: None,
+            state: State::default(),
+        })
+    }
+
+    pub fn import(path: &Path, name: &str) -> Result<Self> {
+        let path = Self::path_(path, name);
+        fs::create_dir_all(&path)?;
+
+        let config = config::standard();
+        let file = File::open(Self::path_state_(&path))?;
+        let mut reader = BufReader::new(file);
+        let state = decode_from_std_read(&mut reader, config)?;
+
+        Ok(Self {
+            height: Height::try_from(Self::path_height_(&path).as_path()).ok(),
+            pathbuf: path,
+            state,
+        })
+    }
+
+    pub fn reset(&mut self) -> Result<()> {
+        self.clear();
+        self.height = None;
+        fs::remove_dir_all(&self.pathbuf)?;
+        fs::create_dir_all(&self.pathbuf)?;
+        Ok(())
+    }
+
+    pub fn flush(&mut self, height: Height) -> Result<()> {
+        self.height = Some(height);
+        height.write(&self.path_height())?;
+
+        let config = config::standard();
+        let file = File::create(self.path_state()).inspect_err(|_| {
+            dbg!(self.path_state());
+        })?;
+        let mut writer = BufWriter::new(file);
+        encode_into_std_write(&self.state, &mut writer, config)?;
+        Ok(())
+    }
+
+    pub fn height(&self) -> Option<Height> {
+        self.height
+    }
+
+    fn path_(path: &Path, name: &str) -> PathBuf {
+        path.join(format!("{name}_price_to_amount"))
+    }
+
+    fn path_state(&self) -> PathBuf {
+        Self::path_state_(&self.pathbuf)
+    }
+    fn path_state_(path: &Path) -> PathBuf {
+        path.join("state")
+    }
+
+    fn path_height(&self) -> PathBuf {
+        Self::path_height_(&self.pathbuf)
+    }
+    fn path_height_(path: &Path) -> PathBuf {
+        path.join("height")
+    }
+}
+
+impl Deref for PriceToAmount {
+    type Target = BTreeMap<Dollars, Sats>;
+    fn deref(&self) -> &Self::Target {
+        &self.state
+    }
+}
+
+impl DerefMut for PriceToAmount {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.state
+    }
+}

crates/brk_computer/src/states/realized.rs

@@ -0,0 +1,104 @@
+use std::cmp::Ordering;
+
+use brk_core::{CheckedSub, Dollars};
+
+use super::SupplyState;
+
+#[derive(Debug, Default, Clone)]
+pub struct RealizedState {
+    pub cap: Dollars,
+    pub profit: Dollars,
+    pub loss: Dollars,
+    pub value_created: Dollars,
+    pub adj_value_created: Dollars,
+    pub value_destroyed: Dollars,
+    pub adj_value_destroyed: Dollars,
+}
+
+impl RealizedState {
+    pub const NAN: Self = Self {
+        cap: Dollars::NAN,
+        profit: Dollars::NAN,
+        loss: Dollars::NAN,
+        value_created: Dollars::NAN,
+        adj_value_created: Dollars::NAN,
+        value_destroyed: Dollars::NAN,
+        adj_value_destroyed: Dollars::NAN,
+    };
+
+    pub fn reset_single_iteration_values(&mut self) {
+        if self.cap != Dollars::NAN {
+            self.profit = Dollars::ZERO;
+            self.loss = Dollars::ZERO;
+            self.value_created = Dollars::ZERO;
+            self.adj_value_created = Dollars::ZERO;
+            self.value_destroyed = Dollars::ZERO;
+            self.adj_value_destroyed = Dollars::ZERO;
+        }
+    }
+
+    pub fn increment(&mut self, supply_state: &SupplyState, price: Dollars) {
+        if supply_state.value.is_zero() {
+            return;
+        }
+
+        self.increment_(price * supply_state.value)
+    }
+
+    pub fn increment_(&mut self, realized_cap: Dollars) {
+        if self.cap == Dollars::NAN {
+            self.cap = Dollars::ZERO;
+            self.profit = Dollars::ZERO;
+            self.loss = Dollars::ZERO;
+            self.value_created = Dollars::ZERO;
+            self.adj_value_created = Dollars::ZERO;
+            self.value_destroyed = Dollars::ZERO;
+            self.adj_value_destroyed = Dollars::ZERO;
+        }
+
+        self.cap += realized_cap;
+    }
+
+    pub fn decrement(&mut self, supply_state: &SupplyState, price: Dollars) {
+        self.decrement_(price * supply_state.value);
+    }
+
+    pub fn decrement_(&mut self, realized_cap: Dollars) {
+        self.cap = self.cap.checked_sub(realized_cap).unwrap();
+    }
+
+    pub fn receive(&mut self, supply_state: &SupplyState, current_price: Dollars) {
+        self.increment(supply_state, current_price);
+    }
+
+    pub fn send(
+        &mut self,
+        supply_state: &SupplyState,
+        current_price: Dollars,
+        prev_price: Dollars,
+        older_than_hour: bool,
+    ) {
+        let current_value = current_price * supply_state.value;
+        let prev_value = prev_price * supply_state.value;
+
+        self.value_created += current_value;
+        self.value_destroyed += prev_value;
+
+        if older_than_hour {
+            self.adj_value_created += current_value;
+            self.adj_value_destroyed += prev_value;
+        }
+
+        match current_price.cmp(&prev_price) {
+            Ordering::Greater => {
+                self.profit += current_value.checked_sub(prev_value).unwrap();
+            }
+            Ordering::Less => {
+                self.loss += prev_value.checked_sub(current_value).unwrap();
+            }
+            Ordering::Equal => {}
+        }
+
+        self.decrement(supply_state, prev_price);
+    }
+}

crates/brk_computer/src/states/supply.rs

@@ -0,0 +1,50 @@
+use std::ops::{Add, AddAssign, SubAssign};
+
+use brk_core::{AddressData, CheckedSub, Sats};
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize)]
+pub struct SupplyState {
+    pub utxos: usize,
+    pub value: Sats,
+}
+
+impl Add<SupplyState> for SupplyState {
+    type Output = Self;
+    fn add(self, rhs: SupplyState) -> Self::Output {
+        Self {
+            utxos: self.utxos + rhs.utxos,
+            value: self.value + rhs.value,
+        }
+    }
+}
+
+impl AddAssign<SupplyState> for SupplyState {
+    fn add_assign(&mut self, rhs: Self) {
+        *self += &rhs;
+    }
+}
+
+impl AddAssign<&SupplyState> for SupplyState {
+    fn add_assign(&mut self, rhs: &Self) {
+        self.utxos += rhs.utxos;
+        self.value += rhs.value;
+    }
+}
+
+impl SubAssign<&SupplyState> for SupplyState {
+    fn sub_assign(&mut self, rhs: &Self) {
+        self.utxos = self.utxos.checked_sub(rhs.utxos).unwrap();
+        self.value = self.value.checked_sub(rhs.value).unwrap();
+    }
+}
+
+impl From<&AddressData> for SupplyState {
+    fn from(value: &AddressData) -> Self {
+        Self {
+            utxos: value.outputs_len as usize,
+            value: value.amount(),
+        }
+    }
+}

crates/brk_computer/src/states/transacted.rs

@@ -0,0 +1,50 @@
+use std::ops::{Add, AddAssign};
+
+use brk_core::{OutputType, Sats};
+
+use crate::{GroupedBySizeRange, GroupedByType};
+
+use super::SupplyState;
+
+#[derive(Default, Debug)]
+pub struct Transacted {
+    pub spendable_supply: SupplyState,
+    pub by_type: GroupedByType<SupplyState>,
+    pub by_size_group: GroupedBySizeRange<SupplyState>,
+}
+
+impl Transacted {
+    #[allow(clippy::inconsistent_digit_grouping)]
+    pub fn iterate(&mut self, value: Sats, _type: OutputType) {
+        let supply = SupplyState { utxos: 1, value };
+
+        *self.by_type.get_mut(_type) += &supply;
+
+        if _type.is_unspendable() {
+            return;
+        }
+
+        self.spendable_supply += &supply;
+
+        *self.by_size_group.get_mut(value) += &supply;
+    }
+}
+
+impl Add for Transacted {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            spendable_supply: self.spendable_supply + rhs.spendable_supply,
+            by_type: self.by_type + rhs.by_type,
+            by_size_group: self.by_size_group + rhs.by_size_group,
+        }
+    }
+}
+
+impl AddAssign for Transacted {
+    fn add_assign(&mut self, rhs: Self) {
+        self.by_size_group += rhs.by_size_group;
+        self.spendable_supply += &rhs.spendable_supply;
+        self.by_type += rhs.by_type;
+    }
+}

crates/brk_computer/src/states/unrealized.rs

@@ -0,0 +1,28 @@
+use brk_core::{Dollars, Sats};
+
+#[derive(Debug, Default, Clone)]
+pub struct UnrealizedState {
+    pub supply_in_profit: Sats,
+    pub supply_even: Sats,
+    pub supply_in_loss: Sats,
+    pub unrealized_profit: Dollars,
+    pub unrealized_loss: Dollars,
+}
+
+impl UnrealizedState {
+    pub const NAN: Self = Self {
+        supply_in_profit: Sats::ZERO,
+        supply_even: Sats::ZERO,
+        supply_in_loss: Sats::ZERO,
+        unrealized_profit: Dollars::NAN,
+        unrealized_loss: Dollars::NAN,
+    };
+
+    pub const ZERO: Self = Self {
+        supply_in_profit: Sats::ZERO,
+        supply_even: Sats::ZERO,
+        supply_in_loss: Sats::ZERO,
+        unrealized_profit: Dollars::ZERO,
+        unrealized_loss: Dollars::ZERO,
+    };
+}