computer: store part 4

crates/brk_core/src/groups/addressindex_to_typeindex_to_outputindex.rs

@@ -1,38 +0,0 @@
-use std::mem;
-
-use derive_deref::{Deref, DerefMut};
-
-use crate::{OutputIndex, TypeIndex};
-
-use super::GroupedByAddressType;
-
-#[derive(Debug, Default, Deref, DerefMut)]
-pub struct AddressIndexToTypeIndedToOutputIndex(
-    GroupedByAddressType<Vec<(TypeIndex, OutputIndex)>>,
-);
-
-impl AddressIndexToTypeIndedToOutputIndex {
-    pub fn merge(&mut self, mut other: Self) {
-        Self::merge_(&mut self.p2pk65, &mut other.p2pk65);
-        Self::merge_(&mut self.p2pk33, &mut other.p2pk33);
-        Self::merge_(&mut self.p2pkh, &mut other.p2pkh);
-        Self::merge_(&mut self.p2sh, &mut other.p2sh);
-        Self::merge_(&mut self.p2wpkh, &mut other.p2wpkh);
-        Self::merge_(&mut self.p2wsh, &mut other.p2wsh);
-        Self::merge_(&mut self.p2tr, &mut other.p2tr);
-        Self::merge_(&mut self.p2a, &mut other.p2a);
-    }
-
-    fn merge_(own: &mut Vec<(TypeIndex, OutputIndex)>, other: &mut Vec<(TypeIndex, OutputIndex)>) {
-        if own.len() >= other.len() {
-            own.append(other);
-        } else {
-            other.append(own);
-            mem::swap(own, other);
-        }
-    }
-
-    pub fn inner(self) -> GroupedByAddressType<Vec<(TypeIndex, OutputIndex)>> {
-        self.0
-    }
-}

crates/brk_core/src/groups/by_address_type.rs

@@ -1,4 +1,7 @@
-use std::ops::{Add, AddAssign};
+use std::{
+    mem,
+    ops::{Add, AddAssign},
+};
 
 use crate::OutputType;
 
@@ -17,6 +20,20 @@ pub struct GroupedByAddressType<T> {
 }
 
 impl<T> GroupedByAddressType<T> {
+    pub fn get(&self, address_type: OutputType) -> Option<&T> {
+        match address_type {
+            OutputType::P2PK65 => Some(&self.p2pk65),
+            OutputType::P2PK33 => Some(&self.p2pk33),
+            OutputType::P2PKH => Some(&self.p2pkh),
+            OutputType::P2SH => Some(&self.p2sh),
+            OutputType::P2WPKH => Some(&self.p2wpkh),
+            OutputType::P2WSH => Some(&self.p2wsh),
+            OutputType::P2TR => Some(&self.p2tr),
+            OutputType::P2A => Some(&self.p2a),
+            _ => None,
+        }
+    }
+
     pub fn get_mut(&mut self, address_type: OutputType) -> Option<&mut T> {
         match address_type {
             OutputType::P2PK65 => Some(&mut self.p2pk65),
@@ -56,6 +73,35 @@ impl<T> GroupedByAddressType<T> {
             (OutputType::P2A, &self.p2a),
         ]
     }
+
+    pub fn as_mut_typed_vec(&mut self) -> [(OutputType, &mut T); 8] {
+        [
+            (OutputType::P2PK65, &mut self.p2pk65),
+            (OutputType::P2PK33, &mut self.p2pk33),
+            (OutputType::P2PKH, &mut self.p2pkh),
+            (OutputType::P2SH, &mut self.p2sh),
+            (OutputType::P2WPKH, &mut self.p2wpkh),
+            (OutputType::P2WSH, &mut self.p2wsh),
+            (OutputType::P2TR, &mut self.p2tr),
+            (OutputType::P2A, &mut self.p2a),
+        ]
+    }
+
+    pub fn into_typed_vec(&mut self) -> [(OutputType, T); 8]
+    where
+        T: Default,
+    {
+        [
+            (OutputType::P2PK65, mem::take(&mut self.p2pk65)),
+            (OutputType::P2PK33, mem::take(&mut self.p2pk33)),
+            (OutputType::P2PKH, mem::take(&mut self.p2pkh)),
+            (OutputType::P2SH, mem::take(&mut self.p2sh)),
+            (OutputType::P2WPKH, mem::take(&mut self.p2wpkh)),
+            (OutputType::P2WSH, mem::take(&mut self.p2wsh)),
+            (OutputType::P2TR, mem::take(&mut self.p2tr)),
+            (OutputType::P2A, mem::take(&mut self.p2a)),
+        ]
+    }
 }
 
 impl<T> GroupedByAddressType<(GroupFilter, T)> {

crates/brk_core/src/groups/mod.rs

@@ -1,5 +1,4 @@
 mod address;
-mod addressindex_to_typeindex_to_outputindex;
 mod by_address_type;
 mod by_date_range;
 mod by_epoch;
@@ -16,7 +15,6 @@ mod filter;
 mod utxo;
 
 pub use address::*;
-pub use addressindex_to_typeindex_to_outputindex::*;
 pub use by_address_type::*;
 pub use by_date_range::*;
 pub use by_epoch::*;

crates/brk_core/src/structs/addressdata.rs

@@ -31,22 +31,26 @@ impl AddressData {
         }
     }
 
-    pub fn receive(&mut self, amount: Sats, price: Dollars) {
+    pub fn receive(&mut self, amount: Sats, price: Option<Dollars>) {
         self.received += amount;
         self.outputs_len += 1;
-        self.realized_cap += price * amount;
+        if let Some(price) = price {
+            self.realized_cap += price * amount;
+        }
     }
 
-    pub fn send(&mut self, amount: Sats, previous_price: Dollars) -> Result<()> {
+    pub fn send(&mut self, amount: Sats, previous_price: Option<Dollars>) -> Result<()> {
         if self.amount() < amount {
             return Err(Error::String("Previous_amount smaller than sent amount"));
         }
         self.sent += amount;
         self.outputs_len -= 1;
-        self.realized_cap = self
-            .realized_cap
-            .checked_sub(previous_price * amount)
-            .unwrap();
+        if let Some(previous_price) = previous_price {
+            self.realized_cap = self
+                .realized_cap
+                .checked_sub(previous_price * amount)
+                .unwrap();
+        }
         Ok(())
     }
 }

crates/brk_core/src/structs/outputtype.rs

@@ -50,6 +50,23 @@ impl OutputType {
         }
     }
 
+    pub fn is_address(&self) -> bool {
+        match self {
+            Self::P2PK65 => true,
+            Self::P2PK33 => true,
+            Self::P2PKH => true,
+            Self::P2MS => false,
+            Self::P2SH => true,
+            Self::OpReturn => false,
+            Self::P2WPKH => true,
+            Self::P2WSH => true,
+            Self::P2TR => true,
+            Self::P2A => true,
+            Self::Empty => false,
+            Self::Unknown => false,
+        }
+    }
+
     pub fn is_unspendable(&self) -> bool {
         !self.is_spendable()
     }