[persist_redesign] Remove Loadable trait

It is not needed.

Also moved `tracker_example_cli::RemoteChain` into it's own file.

Author: evanlinjin

crates/chain/src/local_chain.rs

@@ -3,7 +3,7 @@ use core::convert::Infallible;
 use alloc::collections::{BTreeMap, BTreeSet};
 use bitcoin::BlockHash;
 
-use crate::{BlockId, ChainOracle, Loadable};
+use crate::{BlockId, ChainOracle};
 
 /// This is a local implementation of [`ChainOracle`].
 ///
@@ -43,14 +43,6 @@ impl ChainOracle for LocalChain {
     }
 }
 
-impl Loadable for LocalChain {
-    type ChangeSet = ChangeSet;
-
-    fn load_changeset(&mut self, changeset: Self::ChangeSet) {
-        self.apply_changeset(changeset)
-    }
-}
-
 impl AsRef<BTreeMap<u32, BlockHash>> for LocalChain {
     fn as_ref(&self) -> &BTreeMap<u32, BlockHash> {
         &self.blocks

crates/chain/src/persist.rs

@@ -8,16 +8,16 @@ use crate::Append;
 /// Not all changes to the tracker, which is an in-memory representation of wallet/blockchain
 /// data, needs to be written to disk right away, so [`Persist::stage`] can be used to *stage*
 /// changes first and then [`Persist::commit`] can be used to write changes to disk.
-pub struct Persist<T, C, B> {
+pub struct Persist<B, T, C> {
     backend: B,
     stage: C,
     marker: PhantomData<T>,
 }
 
-impl<T, B> Persist<T, T::ChangeSet, B>
+impl<B, T, C> Persist<B, T, C>
 where
-    T: Loadable,
-    B: PersistBackend<T>,
+    B: PersistBackend<T, C>,
+    C: Default + Append,
 {
     /// Create a new [`Persist`] from [`PersistBackend`].
     pub fn new(backend: B) -> Self {
@@ -31,20 +31,20 @@ where
     /// Stage a `changeset` to be commited later with [`commit`].
     ///
     /// [`commit`]: Self::commit
-    pub fn stage(&mut self, changeset: T::ChangeSet) {
+    pub fn stage(&mut self, changeset: C) {
         self.stage.append(changeset)
     }
 
     /// Get the changes that have not been commited yet.
-    pub fn staged(&self) -> &T::ChangeSet {
+    pub fn staged(&self) -> &C {
         &self.stage
     }
 
     /// Commit the staged changes to the underlying persistance backend.
     ///
     /// Returns a backend-defined error if this fails.
     pub fn commit(&mut self) -> Result<(), B::WriteError> {
-        let mut temp = T::ChangeSet::default();
+        let mut temp = C::default();
         core::mem::swap(&mut temp, &mut self.stage);
         self.backend.write_changes(&temp)
     }
@@ -53,7 +53,7 @@ where
 /// A persistence backend for [`Persist`].
 ///
 /// `T` represents the tracker, the in-memory data structure which we wish to persist.
-pub trait PersistBackend<T: Loadable> {
+pub trait PersistBackend<T, C> {
     /// The error the backend returns when it fails to write.
     type WriteError: core::fmt::Debug;
 
@@ -68,29 +68,21 @@ pub trait PersistBackend<T: Loadable> {
     /// changesets had been applied sequentially.
     ///
     /// [`load_into_tracker`]: Self::load_into_tracker
-    fn write_changes(&mut self, changeset: &T::ChangeSet) -> Result<(), Self::WriteError>;
+    fn write_changes(&mut self, changeset: &C) -> Result<(), Self::WriteError>;
 
     /// Loads all data from the persistence backend into `tracker`.
     fn load_into_tracker(&mut self, tracker: &mut T) -> Result<(), Self::LoadError>;
 }
 
-impl<T: Loadable> PersistBackend<T> for () {
+impl<T, C> PersistBackend<T, C> for () {
     type WriteError = ();
     type LoadError = ();
 
-    fn write_changes(&mut self, _changeset: &T::ChangeSet) -> Result<(), Self::WriteError> {
+    fn write_changes(&mut self, _changeset: &C) -> Result<(), Self::WriteError> {
         Ok(())
     }
 
     fn load_into_tracker(&mut self, _tracker: &mut T) -> Result<(), Self::LoadError> {
         Ok(())
     }
 }
-
-/// A trait that represents a structure which can be loaded with changesets.
-pub trait Loadable {
-    /// The changeset to be loaded into `self`.
-    type ChangeSet: Default + Append;
-    /// Loads the `changeset` into `self`.
-    fn load_changeset(&mut self, changeset: Self::ChangeSet);
-}

crates/file_store/src/store.rs

@@ -5,7 +5,7 @@ use std::{
     path::Path,
 };
 
-use bdk_chain::{Append, Loadable, PersistBackend};
+use bdk_chain::Append;
 use bincode::Options;
 
 use crate::{bincode_options, EntryIter, FileError, IterError};
@@ -14,16 +14,15 @@ use crate::{bincode_options, EntryIter, FileError, IterError};
 ///
 /// The changesets are the results of altering a tracker implementation (`T`).
 #[derive(Debug)]
-pub struct Store<T> {
+pub struct Store<T, C> {
     magic: &'static [u8],
     db_file: File,
-    marker: PhantomData<T>,
+    marker: PhantomData<(T, C)>,
 }
 
-impl<T> Store<T>
+impl<T, C> Store<T, C>
 where
-    T: Loadable,
-    T::ChangeSet: serde::Serialize + serde::de::DeserializeOwned,
+    C: Default + Append + serde::Serialize + serde::de::DeserializeOwned,
 {
     /// Creates a new store from a [`File`].
     ///
@@ -81,7 +80,7 @@ where
     /// **WARNING**: This method changes the write position in the underlying file. You should
     /// always iterate over all entries until `None` is returned if you want your next write to go
     /// at the end; otherwise, you will write over existing entries.
-    pub fn iter_changesets(&mut self) -> Result<EntryIter<'_, T::ChangeSet>, io::Error> {
+    pub fn iter_changesets(&mut self) -> Result<EntryIter<'_, C>, io::Error> {
         self.db_file
             .seek(io::SeekFrom::Start(self.magic.len() as _))?;
 
@@ -100,8 +99,8 @@ where
     ///
     /// **WARNING**: This method changes the write position of the underlying file. The next
     /// changeset will be written over the erroring entry (or the end of the file if none existed).
-    pub fn aggregate_changesets(&mut self) -> (T::ChangeSet, Result<(), IterError>) {
-        let mut changeset = T::ChangeSet::default();
+    pub fn aggregate_changesets(&mut self) -> (C, Result<(), IterError>) {
+        let mut changeset = C::default();
         let result = (|| {
             let iter_changeset = self.iter_changesets()?;
             for next_changeset in iter_changeset {
@@ -121,7 +120,7 @@ where
     ///
     /// **WARNING**: This method does not detect whether the changeset is empty or not, and will
     /// append an empty changeset to the file (not catastrophic, just a waste of space).
-    pub fn append_changeset(&mut self, changeset: &T::ChangeSet) -> Result<(), io::Error> {
+    pub fn append_changeset(&mut self, changeset: &C) -> Result<(), io::Error> {
         bincode_options()
             .serialize_into(&mut self.db_file, changeset)
             .map_err(|e| match *e {
@@ -139,25 +138,6 @@ where
     }
 }
 
-impl<T> PersistBackend<T> for Store<T>
-where
-    T: Loadable,
-    T::ChangeSet: serde::de::DeserializeOwned + serde::Serialize,
-{
-    type WriteError = std::io::Error;
-    type LoadError = IterError;
-
-    fn write_changes(&mut self, changeset: &T::ChangeSet) -> Result<(), Self::WriteError> {
-        Store::append_changeset(self, changeset)
-    }
-
-    fn load_into_tracker(&mut self, tracker: &mut T) -> Result<(), Self::LoadError> {
-        let (changeset, result) = self.aggregate_changesets();
-        tracker.load_changeset(changeset);
-        result
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -213,19 +193,13 @@ mod test {
     #[derive(Debug)]
     struct TestTracker;
 
-    impl Loadable for TestTracker {
-        type ChangeSet = TestChangeSet;
-
-        fn load_changeset(&mut self, _changeset: Self::ChangeSet) {}
-    }
-
     #[test]
     fn new_fails_if_file_is_too_short() {
         let mut file = NamedTempFile::new().unwrap();
         file.write_all(&TEST_MAGIC_BYTES[..TEST_MAGIC_BYTES_LEN - 1])
             .expect("should write");
 
-        match Store::<TestTracker>::new(&TEST_MAGIC_BYTES, file.reopen().unwrap()) {
+        match Store::<TestTracker, TestChangeSet>::new(&TEST_MAGIC_BYTES, file.reopen().unwrap()) {
             Err(FileError::Io(e)) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
             unexpected => panic!("unexpected result: {:?}", unexpected),
         };
@@ -239,7 +213,7 @@ mod test {
         file.write_all(invalid_magic_bytes.as_bytes())
             .expect("should write");
 
-        match Store::<TestTracker>::new(&TEST_MAGIC_BYTES, file.reopen().unwrap()) {
+        match Store::<TestTracker, TestChangeSet>::new(&TEST_MAGIC_BYTES, file.reopen().unwrap()) {
             Err(FileError::InvalidMagicBytes { got, .. }) => {
                 assert_eq!(got, invalid_magic_bytes.as_bytes())
             }
@@ -260,8 +234,9 @@ mod test {
         let mut file = NamedTempFile::new().unwrap();
         file.write_all(&data).expect("should write");
 
-        let mut store = Store::<TestTracker>::new(&TEST_MAGIC_BYTES, file.reopen().unwrap())
-            .expect("should open");
+        let mut store =
+            Store::<TestTracker, TestChangeSet>::new(&TEST_MAGIC_BYTES, file.reopen().unwrap())
+                .expect("should open");
         match store.iter_changesets().expect("seek should succeed").next() {
             Some(Err(IterError::Bincode(_))) => {}
             unexpected_res => panic!("unexpected result: {:?}", unexpected_res),

example-crates/tracker_electrum/src/main.rs

@@ -58,7 +58,7 @@ pub struct ScanOptions {
 }
 
 fn main() -> anyhow::Result<()> {
-    let (args, keymap, tracker, db) = cli::init::<ElectrumCommands, ConfirmationHeightAnchor, _>(
+    let (args, keymap, tracker, db) = cli::init::<ElectrumCommands, ConfirmationHeightAnchor, _, _>(
         DB_MAGIC,
         DB_PATH,
         cli::Tracker::new_local(),