global: cleanup

crates/brk_computer/src/states/price_to_amount.rs

@@ -1,14 +1,14 @@
 use std::{
     collections::BTreeMap,
-    fs::{self, File},
-    io::{BufReader, BufWriter},
+    fs,
+    io::{Cursor, Read},
     path::{Path, PathBuf},
 };
 
-use bincode::{Decode, Encode, config, decode_from_std_read, encode_into_std_write};
-use brk_core::{Dollars, Height, Result, Sats};
+use brk_core::{Dollars, Error, Height, Result, Sats};
 use derive_deref::{Deref, DerefMut};
 use serde::{Deserialize, Serialize};
+use zerocopy::{FromBytes, IntoBytes};
 
 use crate::states::SupplyState;
 
@@ -19,9 +19,6 @@ pub struct PriceToAmount {
     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 {
@@ -35,10 +32,7 @@ impl PriceToAmount {
         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)?;
+        let state = State::deserialize(&fs::read(&path)?)?;
 
         Ok(Self {
             height: Height::try_from(Self::path_height_(&path).as_path()).ok(),
@@ -86,13 +80,7 @@ impl PriceToAmount {
     pub fn flush(&mut self, height: Height) -> Result<()> {
         self.height = Some(height);
         height.write(&self.path_height())?;
-
-        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::standard())?;
-
+        fs::write(self.path_state(), self.state.serialize())?;
         Ok(())
     }
 
@@ -118,3 +106,47 @@ impl PriceToAmount {
         path.join("height")
     }
 }
+
+#[derive(Clone, Default, Debug, Deref, DerefMut, Serialize, Deserialize)]
+struct State(BTreeMap<Dollars, Sats>);
+
+impl State {
+    fn serialize(&self) -> Vec<u8> {
+        let len = self.len();
+
+        let mut buffer = Vec::with_capacity(8 + len * 16);
+
+        buffer.extend_from_slice(len.as_bytes());
+
+        self.iter().for_each(|(key, value)| {
+            buffer.extend_from_slice(key.as_bytes());
+            buffer.extend_from_slice(value.as_bytes());
+        });
+
+        buffer
+    }
+
+    fn deserialize(data: &[u8]) -> Result<Self> {
+        let mut cursor = Cursor::new(data);
+        let mut buffer = [0u8; 8];
+
+        cursor
+            .read_exact(&mut buffer)
+            .map_err(|_| Error::Str("Failed to read entry count"))?;
+        let entry_count = usize::read_from_bytes(&buffer)?;
+
+        let mut map = BTreeMap::new();
+
+        for _ in 0..entry_count {
+            cursor.read_exact(&mut buffer)?;
+            let key = Dollars::read_from_bytes(&buffer)?;
+
+            cursor.read_exact(&mut buffer)?;
+            let value = Sats::read_from_bytes(&buffer)?;
+
+            map.insert(key, value);
+        }
+
+        Ok(Self(map))
+    }
+}