refactor(persist): update file_store, sqlite, wallet to use bdk_chain::persist

Also update examples and remove bdk_persist crate.

Author: notmandatory

Cargo.toml

@@ -9,7 +9,6 @@ members = [
     "crates/esplora",
     "crates/bitcoind_rpc",
     "crates/hwi",
-    "crates/persist",
     "crates/testenv",
     "example-crates/example_cli",
     "example-crates/example_electrum",

crates/chain/src/keychain/txout_index.rs

@@ -308,7 +308,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
 
     /// Return a reference to the internal [`SpkTxOutIndex`].
     ///
-    /// **WARNING:** The internal index will contain lookahead spks. Refer to
+    /// **WARNING**: The internal index will contain lookahead spks. Refer to
     /// [struct-level docs](KeychainTxOutIndex) for more about `lookahead`.
     pub fn inner(&self) -> &SpkTxOutIndex<(DescriptorId, u32)> {
         &self.inner

crates/chain/src/persist.rs

@@ -1,7 +1,7 @@
-//! This module is home to the [`Persist`] trait which defines the behavior of a data store
+//! This module is home to the [`PersistBackend`] trait which defines the behavior of a data store
 //! required to persist changes made to BDK data structures.
 //!
-//! The [`StagedPersist`] type provides a convenient wrapper around implementations of [`Persist`] that
+//! The [`StagedPersistBackend`] type provides a convenient wrapper around implementations of [`PersistBackend`] that
 //! allows changes to be staged before committing them.
 //!
 //! The [`CombinedChangeSet`] type encapsulates a combination of [`crate`] structures that are
@@ -92,7 +92,7 @@ impl<K, A> From<indexed_tx_graph::ChangeSet<A, keychain::ChangeSet<K>>>
 ///
 /// `C` represents the changeset; a datatype that records changes made to in-memory data structures
 /// that are to be persisted, or retrieved from persistence.
-pub trait Persist<C> {
+pub trait PersistBackend<C> {
     /// The error the backend returns when it fails to write.
     type WriteError: Debug + Display;
 
@@ -113,7 +113,7 @@ pub trait Persist<C> {
     fn load_changes(&mut self) -> Result<Option<C>, Self::LoadError>;
 }
 
-impl<C> Persist<C> for () {
+impl<C> PersistBackend<C> for () {
     type WriteError = Infallible;
     type LoadError = Infallible;
 
@@ -132,7 +132,7 @@ impl<C> Persist<C> for () {
 /// `C` represents the changeset; a datatype that records changes made to in-memory data structures
 /// that are to be persisted, or retrieved from persistence.
 #[async_trait]
-pub trait PersistAsync<C> {
+pub trait PersistBackendAsync<C> {
     /// The error the backend returns when it fails to write.
     type WriteError: Debug + Display;
 
@@ -155,7 +155,7 @@ pub trait PersistAsync<C> {
 
 #[cfg(feature = "async")]
 #[async_trait]
-impl<C> PersistAsync<C> for () {
+impl<C> PersistBackendAsync<C> for () {
     type WriteError = Infallible;
     type LoadError = Infallible;
 
@@ -168,17 +168,17 @@ impl<C> PersistAsync<C> for () {
     }
 }
 
-/// `StagedPersist` adds a convenient staging area for changesets before they are persisted.
+/// `StagedPersistBackend` adds a convenient staging area for changesets before they are persisted.
 ///
 /// Not all changes to the in-memory representation needs to be written to disk right away, so
-/// [`crate::persist::StagedPersist::stage`] can be used to *stage* changes first and then
-/// [`crate::persist::StagedPersist::commit`] can be used to write changes to disk.
-pub struct StagedPersist<C, P: Persist<C>> {
+/// [`crate::persist::StagedPersistBackend::stage`] can be used to *stage* changes first and then
+/// [`crate::persist::StagedPersistBackend::commit`] can be used to write changes to disk.
+pub struct StagedPersistBackend<C, P: PersistBackend<C>> {
     inner: P,
     stage: C,
 }
 
-impl<C, P: Persist<C>> Persist<C> for StagedPersist<C, P> {
+impl<C, P: PersistBackend<C>> PersistBackend<C> for StagedPersistBackend<C, P> {
     type WriteError = P::WriteError;
     type LoadError = P::LoadError;
 
@@ -191,16 +191,16 @@ impl<C, P: Persist<C>> Persist<C> for StagedPersist<C, P> {
     }
 }
 
-impl<C, P> StagedPersist<C, P>
+impl<C, P> StagedPersistBackend<C, P>
 where
     C: Default + Append,
-    P: Persist<C>,
+    P: PersistBackend<C>,
 {
-    /// Create a new [`StagedPersist`] adding staging to an inner data store that implements
-    /// [`Persist`].
-    pub fn new(persist: P) -> Self {
+    /// Create a new [`StagedPersistBackend`] adding staging to an inner data store that implements
+    /// [`PersistBackend`].
+    pub fn new(persist_backend: P) -> Self {
         Self {
-            inner: persist,
+            inner: persist_backend,
             stage: Default::default(),
         }
     }
@@ -258,16 +258,18 @@ where
 /// `StagedPersistAsync` adds a convenient async staging area for changesets before they are persisted.
 ///
 /// Not all changes to the in-memory representation needs to be written to disk right away, so
-/// [`StagedPersistAsync::stage`] can be used to *stage* changes first and then
-/// [`StagedPersistAsync::commit`] can be used to write changes to disk.
-pub struct StagedPersistAsync<C, P: PersistAsync<C>> {
+/// [`StagedPersistBackendAsync::stage`] can be used to *stage* changes first and then
+/// [`StagedPersistBackendAsync::commit`] can be used to write changes to disk.
+pub struct StagedPersistBackendAsync<C, P: PersistBackendAsync<C>> {
     inner: P,
     staged: C,
 }
 
 #[cfg(feature = "async")]
 #[async_trait]
-impl<C: Send + Sync, P: PersistAsync<C> + Send> PersistAsync<C> for StagedPersistAsync<C, P> {
+impl<C: Send + Sync, P: PersistBackendAsync<C> + Send> PersistBackendAsync<C>
+    for StagedPersistBackendAsync<C, P>
+{
     type WriteError = P::WriteError;
     type LoadError = P::LoadError;
 
@@ -281,16 +283,16 @@ impl<C: Send + Sync, P: PersistAsync<C> + Send> PersistAsync<C> for StagedPersis
 }
 
 #[cfg(feature = "async")]
-impl<C, P> StagedPersistAsync<C, P>
+impl<C, P> StagedPersistBackendAsync<C, P>
 where
     C: Default + Append + Send + Sync,
-    P: PersistAsync<C> + Send,
+    P: PersistBackendAsync<C> + Send,
 {
-    /// Create a new [`StagedPersistAsync`] adding staging to an inner data store that implements
-    /// [`PersistAsync`].
-    pub fn new(persist: P) -> Self {
+    /// Create a new [`StagedPersistBackendAsync`] adding staging to an inner data store that implements
+    /// [`PersistBackendAsync`].
+    pub fn new(persist_backend: P) -> Self {
         Self {
-            inner: persist,
+            inner: persist_backend,
             staged: Default::default(),
         }
     }
@@ -349,7 +351,7 @@ where
 mod test {
     extern crate core;
 
-    use crate::persist::{Persist, StagedPersist};
+    use crate::persist::{PersistBackend, StagedPersistBackend};
     use crate::Append;
     use std::error::Error;
     use std::fmt::{self, Display, Formatter};
@@ -395,7 +397,7 @@ mod test {
         }
     }
 
-    impl<C> Persist<C> for TestBackend<C>
+    impl<C> PersistBackend<C> for TestBackend<C>
     where
         C: Default + Append + Clone + ToString,
     {
@@ -426,7 +428,7 @@ mod test {
             changeset: TestChangeSet(None),
         };
 
-        let mut staged_backend = StagedPersist::new(backend);
+        let mut staged_backend = StagedPersistBackend::new(backend);
         staged_backend.stage(TestChangeSet(Some("ONE".to_string())));
         staged_backend.stage(TestChangeSet(None));
         staged_backend.stage(TestChangeSet(Some("TWO".to_string())));
@@ -446,7 +448,7 @@ mod test {
         let backend = TestBackend {
             changeset: TestChangeSet(None),
         };
-        let mut staged_backend = StagedPersist::new(backend);
+        let mut staged_backend = StagedPersistBackend::new(backend);
         staged_backend.stage(TestChangeSet(Some("ERROR".to_string())));
         let result = staged_backend.commit();
         assert!(matches!(result, Err(e) if e == FailedWrite));

crates/file_store/Cargo.toml

@@ -11,9 +11,7 @@ authors = ["Bitcoin Dev Kit Developers"]
 readme = "README.md"
 
 [dependencies]
-anyhow = { version = "1", default-features = false }
 bdk_chain = { path = "../chain", version = "0.15.0", features = [ "serde", "miniscript" ] }
-bdk_persist = { path = "../persist", version = "0.3.0"}
 bincode = { version = "1" }
 serde = { version = "1", features = ["derive"] }
 

crates/file_store/README.md

@@ -1,6 +1,6 @@
 # BDK File Store
 
-This is a simple append-only flat file implementation of [`PersistBackend`](bdk_persist::PersistBackend).
+This is a simple append-only flat file implementation of [`Persist`](bdk_chain::persist::Persist).
 
 The main structure is [`Store`] which works with any [`bdk_chain`] based changesets to persist data into a flat file.
 

crates/file_store/src/store.rs

@@ -1,7 +1,6 @@
 use crate::{bincode_options, EntryIter, FileError, IterError};
-use anyhow::anyhow;
+use bdk_chain::persist::PersistBackend;
 use bdk_chain::Append;
-use bdk_persist::PersistBackend;
 use bincode::Options;
 use std::{
     fmt::{self, Debug},
@@ -25,19 +24,21 @@ where
 impl<C> PersistBackend<C> for Store<C>
 where
     C: Append
+        + Debug
         + serde::Serialize
         + serde::de::DeserializeOwned
         + core::marker::Send
         + core::marker::Sync,
 {
-    fn write_changes(&mut self, changeset: &C) -> anyhow::Result<()> {
+    type WriteError = io::Error;
+    type LoadError = AggregateChangesetsError<C>;
+
+    fn write_changes(&mut self, changeset: &C) -> Result<(), Self::WriteError> {
         self.append_changeset(changeset)
-            .map_err(|e| anyhow!(e).context("failed to write changes to persistence backend"))
     }
 
-    fn load_from_persistence(&mut self) -> anyhow::Result<Option<C>> {
+    fn load_changes(&mut self) -> Result<Option<C>, Self::LoadError> {
         self.aggregate_changesets()
-            .map_err(|e| anyhow!(e.iter_error).context("error loading from persistence backend"))
     }
 }
 

crates/hwi/src/lib.rs

@@ -18,7 +18,7 @@
 //! let first_device = devices.remove(0)?;
 //! let custom_signer = HWISigner::from_device(&first_device, Network::Testnet.into())?;
 //!
-//! # let mut wallet = Wallet::new_no_persist(
+//! # let mut wallet = Wallet::new(
 //! #     "",
 //! #     "",
 //! #     Network::Testnet,