10456741773

Committed 19 Aug 2024 03:56PM UTC coverage: 81.844% (-0.2%) from 82.004%

Build # 10456741773

Build Type

push

github

Committed by

notmandatory

Commit Message

Merge bitcoindevkit/bdk#1547: Simplify wallet persistence

340808e82 docs(wallet): fixes/improvements for `persisted` and `params` types (志宇)
960029324 feat(wallet)!: add persister (`P`) type param to `PersistedWallet<P>` (志宇)
06160574b revert(chain)!: rm `persit` module (志宇)
a9c5f761c feat(wallet)!: remove dependency on `bdk_chain::Staged` (志宇)
06a9d6c72 feat(chain,wallet)!: publicize `.init_sqlite_tables` changeset methods (志宇)
039622fd1 feat(wallet)!: introduce `WalletPersister` (志宇)

Pull request description:

  ### Description

  Removed the persistence module in `bdk_chain` (which contained the `PersistWith` and `PersistAsyncWith` traits and a `Persisted<T>` wrapper). Replaced it with simplified versions that are `Wallet`-specific.

  The new traits (`WalletPersister` and `AsyncWalletPersister`) are simpler since they have less type-parameters (being wallet-specific). The old versions were more complex as they were intended to be used with any type. However, we need more time to finalize a works-for-all-bdk-types persistence API.

  Additionally, `WalletPersister` and `AsyncWalletPersister` also introduce the `initialize` method. It is handy to contain db-initialization (i.e. create tables for SQL) here. We can call `initialize` in `PersistedWallet` constructors. So the `PersistedWallet::persist` method does not need to ensure the database is initialized. To accommodate this, I made the `.init_sqlite_table` methods on changeset-types public, and removed the call of this in `from_sqlite` and `.persist_to_sqlite`. The `initialize` method now loads from the persister, so the `load` associated function is removed.

  There was a bug in the old `PersistAsyncWith` trait where the lifetime bounds were not strict enough (refer to the conversation in #1552). This is now f... (continued)

Run Details

83 of 155 new or added lines in 5 files covered. (53.55%)

5 existing lines in 1 file now uncovered.

11121 of 13588 relevant lines covered (81.84%)

13793.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.15

/crates/wallet/src/wallet/persisted.rs

use core::{
    fmt,
    future::Future,
    marker::PhantomData,
    ops::{Deref, DerefMut},
    pin::Pin,
};

use alloc::boxed::Box;
use chain::Merge;

use crate::{descriptor::DescriptorError, ChangeSet, CreateParams, LoadParams, Wallet};

/// Trait that persists [`PersistedWallet`].
///
/// For an async version, use [`AsyncWalletPersister`].
///
/// Associated functions of this trait should not be called directly, and the trait is designed so
/// that associated functions are hard to find (since they are not methods!). [`WalletPersister`] is
/// used by [`PersistedWallet`] (a light wrapper around [`Wallet`]) which enforces some level of
/// safety. Refer to [`PersistedWallet`] for more about the safety checks.
pub trait WalletPersister {
    /// Error type of the persister.
    type Error;

    /// Initialize the `persister` and load all data.
    ///
    /// This is called by [`PersistedWallet::create`] and [`PersistedWallet::load`] to ensure
    /// the [`WalletPersister`] is initialized and returns all data in the `persister`.
    ///
    /// # Implementation Details
    ///
    /// The database schema of the `persister` (if any), should be initialized and migrated here.
    ///
    /// The implementation must return all data currently stored in the `persister`. If there is no
    /// data, return an empty changeset (using [`ChangeSet::default()`]).
    ///
    /// Error should only occur on database failure. Multiple calls to `initialize` should not
    /// error. Calling `initialize` inbetween calls to `persist` should not error.
    ///
    /// Calling [`persist`] before the `persister` is `initialize`d may error. However, some
    /// persister implementations may NOT require initialization at all (and not error).
    ///
    /// [`persist`]: WalletPersister::persist
    fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error>;

    /// Persist the given `changeset` to the `persister`.
    ///
    /// This method can fail if the `persister` is not [`initialize`]d.
    ///
    /// [`initialize`]: WalletPersister::initialize
    fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error>;
}

type FutureResult<'a, T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'a>>;

/// Async trait that persists [`PersistedWallet`].
///
/// For a blocking version, use [`WalletPersister`].
///
/// Associated functions of this trait should not be called directly, and the trait is designed so
/// that associated functions are hard to find (since they are not methods!). [`AsyncWalletPersister`] is
/// used by [`PersistedWallet`] (a light wrapper around [`Wallet`]) which enforces some level of
/// safety. Refer to [`PersistedWallet`] for more about the safety checks.
pub trait AsyncWalletPersister {
    /// Error type of the persister.
    type Error;

    /// Initialize the `persister` and load all data.
    ///
    /// This is called by [`PersistedWallet::create_async`] and [`PersistedWallet::load_async`] to
    /// ensure the [`AsyncWalletPersister`] is initialized and returns all data in the `persister`.
    ///
    /// # Implementation Details
    ///
    /// The database schema of the `persister` (if any), should be initialized and migrated here.
    ///
    /// The implementation must return all data currently stored in the `persister`. If there is no
    /// data, return an empty changeset (using [`ChangeSet::default()`]).
    ///
    /// Error should only occur on database failure. Multiple calls to `initialize` should not
    /// error. Calling `initialize` inbetween calls to `persist` should not error.
    ///
    /// Calling [`persist`] before the `persister` is `initialize`d may error. However, some
    /// persister implementations may NOT require initialization at all (and not error).
    ///
    /// [`persist`]: AsyncWalletPersister::persist
    fn initialize<'a>(persister: &'a mut Self) -> FutureResult<'a, ChangeSet, Self::Error>
    where
        Self: 'a;

    /// Persist the given `changeset` to the `persister`.
    ///
    /// This method can fail if the `persister` is not [`initialize`]d.
    ///
    /// [`initialize`]: AsyncWalletPersister::initialize
    fn persist<'a>(
        persister: &'a mut Self,
        changeset: &'a ChangeSet,
    ) -> FutureResult<'a, (), Self::Error>
    where
        Self: 'a;
}

/// Represents a persisted wallet which persists into type `P`.
///
/// This is a light wrapper around [`Wallet`] that enforces some level of safety-checking when used
/// with a [`WalletPersister`] or [`AsyncWalletPersister`] implementation. Safety checks assume that
/// [`WalletPersister`] and/or [`AsyncWalletPersister`] are implemented correctly.
///
/// Checks include:
///
/// * Ensure the persister is initialized before data is persisted.
/// * Ensure there were no previously persisted wallet data before creating a fresh wallet and
///     persisting it.
/// * Only clear the staged changes of [`Wallet`] after persisting succeeds.
/// * Ensure the wallet is persisted to the same `P` type as when created/loaded. Note that this is
///     not completely fool-proof as you can have multiple instances of the same `P` type that are
///     connected to different databases.
#[derive(Debug)]
pub struct PersistedWallet<P> {
    inner: Wallet,
    marker: PhantomData<P>,
}

impl<P> Deref for PersistedWallet<P> {
    type Target = Wallet;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<P> DerefMut for PersistedWallet<P> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

/// Methods when `P` is a [`WalletPersister`].
impl<P: WalletPersister> PersistedWallet<P> {
    /// Create a new [`PersistedWallet`] with the given `persister` and `params`.
    pub fn create(
        persister: &mut P,
        params: CreateParams,
    ) -> Result<Self, CreateWithPersistError<P::Error>> {
        let existing = P::initialize(persister).map_err(CreateWithPersistError::Persist)?;
        if !existing.is_empty() {
            return Err(CreateWithPersistError::DataAlreadyExists(existing));
        }
        let mut inner =
            Wallet::create_with_params(params).map_err(CreateWithPersistError::Descriptor)?;
        if let Some(changeset) = inner.take_staged() {
            P::persist(persister, &changeset).map_err(CreateWithPersistError::Persist)?;
        }
        Ok(Self {
            inner,
            marker: PhantomData,
        })
    }

    /// Load a previously [`PersistedWallet`] from the given `persister` and `params`.
    pub fn load(
        persister: &mut P,
        params: LoadParams,
    ) -> Result<Option<Self>, LoadWithPersistError<P::Error>> {
        let changeset = P::initialize(persister).map_err(LoadWithPersistError::Persist)?;
        Wallet::load_with_params(changeset, params)
            .map(|opt| {
                opt.map(|inner| PersistedWallet {
                    inner,
                    marker: PhantomData,
                })
            })
            .map_err(LoadWithPersistError::InvalidChangeSet)
    }

    /// Persist staged changes of wallet into `persister`.
    ///
    /// Returns whether any new changes were persisted.
    ///
    /// If the `persister` errors, the staged changes will not be cleared.
    pub fn persist(&mut self, persister: &mut P) -> Result<bool, P::Error> {
        match self.inner.staged_mut() {
            Some(stage) => {
                P::persist(persister, &*stage)?;
                let _ = stage.take();
                Ok(true)
            }
            None => Ok(false),
        }
    }
}

/// Methods when `P` is an [`AsyncWalletPersister`].
impl<P: AsyncWalletPersister> PersistedWallet<P> {
    /// Create a new [`PersistedWallet`] with the given async `persister` and `params`.
    pub async fn create_async(
        persister: &mut P,
        params: CreateParams,
    ) -> Result<Self, CreateWithPersistError<P::Error>> {
        let existing = P::initialize(persister)
            .await
            .map_err(CreateWithPersistError::Persist)?;
        if !existing.is_empty() {
            return Err(CreateWithPersistError::DataAlreadyExists(existing));
        }
        let mut inner =
            Wallet::create_with_params(params).map_err(CreateWithPersistError::Descriptor)?;
        if let Some(changeset) = inner.take_staged() {
            P::persist(persister, &changeset)
                .await
                .map_err(CreateWithPersistError::Persist)?;
        }
        Ok(Self {
            inner,
            marker: PhantomData,
        })
    }

    /// Load a previously [`PersistedWallet`] from the given async `persister` and `params`.
    pub async fn load_async(
        persister: &mut P,
        params: LoadParams,
    ) -> Result<Option<Self>, LoadWithPersistError<P::Error>> {
        let changeset = P::initialize(persister)
            .await
            .map_err(LoadWithPersistError::Persist)?;
        Wallet::load_with_params(changeset, params)
            .map(|opt| {
                opt.map(|inner| PersistedWallet {
                    inner,
                    marker: PhantomData,
                })
            })
            .map_err(LoadWithPersistError::InvalidChangeSet)
    }

    /// Persist staged changes of wallet into an async `persister`.
    ///
    /// Returns whether any new changes were persisted.
    ///
    /// If the `persister` errors, the staged changes will not be cleared.
    pub async fn persist_async<'a>(&'a mut self, persister: &mut P) -> Result<bool, P::Error> {
        match self.inner.staged_mut() {
            Some(stage) => {
                P::persist(persister, &*stage).await?;
                let _ = stage.take();
                Ok(true)
            }
            None => Ok(false),
        }
    }
}

#[cfg(feature = "rusqlite")]
impl<'c> WalletPersister for bdk_chain::rusqlite::Transaction<'c> {
    type Error = bdk_chain::rusqlite::Error;

    fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {
        ChangeSet::init_sqlite_tables(&*persister)?;
        ChangeSet::from_sqlite(persister)
    }

    fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {
        changeset.persist_to_sqlite(persister)
    }
}

#[cfg(feature = "rusqlite")]
impl WalletPersister for bdk_chain::rusqlite::Connection {
    type Error = bdk_chain::rusqlite::Error;

    fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {
        let db_tx = persister.transaction()?;
        ChangeSet::init_sqlite_tables(&db_tx)?;
        let changeset = ChangeSet::from_sqlite(&db_tx)?;
        db_tx.commit()?;
        Ok(changeset)
    }

    fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {
        let db_tx = persister.transaction()?;
        changeset.persist_to_sqlite(&db_tx)?;
        db_tx.commit()
    }
}

/// Error for [`bdk_file_store`]'s implementation of [`WalletPersister`].
#[cfg(feature = "file_store")]
#[derive(Debug)]
pub enum FileStoreError {
    /// Error when loading from the store.
    Load(bdk_file_store::AggregateChangesetsError<ChangeSet>),
    /// Error when writing to the store.
    Write(std::io::Error),
}

#[cfg(feature = "file_store")]
impl core::fmt::Display for FileStoreError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use core::fmt::Display;
        match self {
            FileStoreError::Load(e) => Display::fmt(e, f),
            FileStoreError::Write(e) => Display::fmt(e, f),
        }
    }
}

#[cfg(feature = "file_store")]
impl std::error::Error for FileStoreError {}

#[cfg(feature = "file_store")]
impl WalletPersister for bdk_file_store::Store<ChangeSet> {
    type Error = FileStoreError;

    fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {
        persister
            .aggregate_changesets()
            .map(Option::unwrap_or_default)
            .map_err(FileStoreError::Load)
    }

    fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {
        persister
            .append_changeset(changeset)
            .map_err(FileStoreError::Write)
    }
}

/// Error type for [`PersistedWallet::load`].
#[derive(Debug, PartialEq)]
pub enum LoadWithPersistError<E> {
    /// Error from persistence.
    Persist(E),
    /// Occurs when the loaded changeset cannot construct [`Wallet`].
    InvalidChangeSet(crate::LoadError),
}

impl<E: fmt::Display> fmt::Display for LoadWithPersistError<E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Persist(err) => fmt::Display::fmt(err, f),
            Self::InvalidChangeSet(err) => fmt::Display::fmt(&err, f),
        }
    }
}

#[cfg(feature = "std")]
impl<E: fmt::Debug + fmt::Display> std::error::Error for LoadWithPersistError<E> {}

/// Error type for [`PersistedWallet::create`].
#[derive(Debug)]
pub enum CreateWithPersistError<E> {
    /// Error from persistence.
    Persist(E),
    /// Persister already has wallet data.
    DataAlreadyExists(ChangeSet),
    /// Occurs when the loaded changeset cannot construct [`Wallet`].
    Descriptor(DescriptorError),
}

impl<E: fmt::Display> fmt::Display for CreateWithPersistError<E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Persist(err) => fmt::Display::fmt(err, f),
            Self::DataAlreadyExists(changeset) => write!(
                f,
                "Cannot create wallet in persister which already contains wallet data: {:?}",
                changeset
            ),
            Self::Descriptor(err) => fmt::Display::fmt(&err, f),
        }
    }
}

#[cfg(feature = "std")]
impl<E: fmt::Debug + fmt::Display> std::error::Error for CreateWithPersistError<E> {}

1	use core::{
2	fmt,
3	future::Future,
4	marker::PhantomData,
5	ops::{Deref, DerefMut},
6	pin::Pin,
7	};
8
9	use alloc::boxed::Box;
10	use chain::Merge;
11
12	use crate::{descriptor::DescriptorError, ChangeSet, CreateParams, LoadParams, Wallet};
13
14	/// Trait that persists [`PersistedWallet`].
15	///
16	/// For an async version, use [`AsyncWalletPersister`].
17	///
18	/// Associated functions of this trait should not be called directly, and the trait is designed so
19	/// that associated functions are hard to find (since they are not methods!). [`WalletPersister`] is
20	/// used by [`PersistedWallet`] (a light wrapper around [`Wallet`]) which enforces some level of
21	/// safety. Refer to [`PersistedWallet`] for more about the safety checks.
22	pub trait WalletPersister {
23	/// Error type of the persister.
24	type Error;
25
26	/// Initialize the `persister` and load all data.
27	///
28	/// This is called by [`PersistedWallet::create`] and [`PersistedWallet::load`] to ensure
29	/// the [`WalletPersister`] is initialized and returns all data in the `persister`.
30	///
31	/// # Implementation Details
32	///
33	/// The database schema of the `persister` (if any), should be initialized and migrated here.
34	///
35	/// The implementation must return all data currently stored in the `persister`. If there is no
36	/// data, return an empty changeset (using [`ChangeSet::default()`]).
37	///
38	/// Error should only occur on database failure. Multiple calls to `initialize` should not
39	/// error. Calling `initialize` inbetween calls to `persist` should not error.
40	///
41	/// Calling [`persist`] before the `persister` is `initialize`d may error. However, some
42	/// persister implementations may NOT require initialization at all (and not error).
43	///
44	/// [`persist`]: WalletPersister::persist
45	fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error>;
46
47	/// Persist the given `changeset` to the `persister`.
48	///
49	/// This method can fail if the `persister` is not [`initialize`]d.
50	///
51	/// [`initialize`]: WalletPersister::initialize
52	fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error>;
53	}
54
55	type FutureResult<'a, T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'a>>;
56
57	/// Async trait that persists [`PersistedWallet`].
58	///
59	/// For a blocking version, use [`WalletPersister`].
60	///
61	/// Associated functions of this trait should not be called directly, and the trait is designed so
62	/// that associated functions are hard to find (since they are not methods!). [`AsyncWalletPersister`] is
63	/// used by [`PersistedWallet`] (a light wrapper around [`Wallet`]) which enforces some level of
64	/// safety. Refer to [`PersistedWallet`] for more about the safety checks.
65	pub trait AsyncWalletPersister {
66	/// Error type of the persister.
67	type Error;
68
69	/// Initialize the `persister` and load all data.
70	///
71	/// This is called by [`PersistedWallet::create_async`] and [`PersistedWallet::load_async`] to
72	/// ensure the [`AsyncWalletPersister`] is initialized and returns all data in the `persister`.
73	///
74	/// # Implementation Details
75	///
76	/// The database schema of the `persister` (if any), should be initialized and migrated here.
77	///
78	/// The implementation must return all data currently stored in the `persister`. If there is no
79	/// data, return an empty changeset (using [`ChangeSet::default()`]).
80	///
81	/// Error should only occur on database failure. Multiple calls to `initialize` should not
82	/// error. Calling `initialize` inbetween calls to `persist` should not error.
83	///
84	/// Calling [`persist`] before the `persister` is `initialize`d may error. However, some
85	/// persister implementations may NOT require initialization at all (and not error).
86	///
87	/// [`persist`]: AsyncWalletPersister::persist
88	fn initialize<'a>(persister: &'a mut Self) -> FutureResult<'a, ChangeSet, Self::Error>
89	where
90	Self: 'a;
91
92	/// Persist the given `changeset` to the `persister`.
93	///
94	/// This method can fail if the `persister` is not [`initialize`]d.
95	///
96	/// [`initialize`]: AsyncWalletPersister::initialize
97	fn persist<'a>(
98	persister: &'a mut Self,
99	changeset: &'a ChangeSet,
100	) -> FutureResult<'a, (), Self::Error>
101	where
102	Self: 'a;
103	}
104
105	/// Represents a persisted wallet which persists into type `P`.
106	///
107	/// This is a light wrapper around [`Wallet`] that enforces some level of safety-checking when used
108	/// with a [`WalletPersister`] or [`AsyncWalletPersister`] implementation. Safety checks assume that
109	/// [`WalletPersister`] and/or [`AsyncWalletPersister`] are implemented correctly.
110	///
111	/// Checks include:
112	///
113	/// * Ensure the persister is initialized before data is persisted.
114	/// * Ensure there were no previously persisted wallet data before creating a fresh wallet and
115	/// persisting it.
116	/// * Only clear the staged changes of [`Wallet`] after persisting succeeds.
117	/// * Ensure the wallet is persisted to the same `P` type as when created/loaded. Note that this is
118	/// not completely fool-proof as you can have multiple instances of the same `P` type that are
119	/// connected to different databases.
120	#[derive(Debug)]
121	pub struct PersistedWallet<P> {
122	inner: Wallet,
123	marker: PhantomData<P>,
124	}
125
126	impl<P> Deref for PersistedWallet<P> {
127	type Target = Wallet;
128
129	fn deref(&self) -> &Self::Target {	15✔
130	&self.inner	15✔
131	}	15✔
132	}
133
134	impl<P> DerefMut for PersistedWallet<P> {
135	fn deref_mut(&mut self) -> &mut Self::Target {	3✔
136	&mut self.inner	3✔
137	}	3✔
138	}
139
140	/// Methods when `P` is a [`WalletPersister`].
141	impl<P: WalletPersister> PersistedWallet<P> {
142	/// Create a new [`PersistedWallet`] with the given `persister` and `params`.
143	pub fn create(	5✔
144	persister: &mut P,	5✔
145	params: CreateParams,	5✔
146	) -> Result<Self, CreateWithPersistError<P::Error>> {	5✔
147	let existing = P::initialize(persister).map_err(CreateWithPersistError::Persist)?;	5✔
148	if !existing.is_empty() {	5✔
NEW 149	return Err(CreateWithPersistError::DataAlreadyExists(existing));	×
150	}	5✔
151	let mut inner =	5✔
152	Wallet::create_with_params(params).map_err(CreateWithPersistError::Descriptor)?;	5✔
153	if let Some(changeset) = inner.take_staged() {	5✔
154	P::persist(persister, &changeset).map_err(CreateWithPersistError::Persist)?;	5✔
NEW 155	}	×
156	Ok(Self {	5✔
157	inner,	5✔
158	marker: PhantomData,	5✔
159	})	5✔
160	}	5✔
161
162	/// Load a previously [`PersistedWallet`] from the given `persister` and `params`.
163	pub fn load(	14✔
164	persister: &mut P,	14✔
165	params: LoadParams,	14✔
166	) -> Result<Option<Self>, LoadWithPersistError<P::Error>> {	14✔
167	let changeset = P::initialize(persister).map_err(LoadWithPersistError::Persist)?;	14✔
168	Wallet::load_with_params(changeset, params)	14✔
169	.map(\|opt\| {	14✔
170	opt.map(\|inner\| PersistedWallet {	5✔
171	inner,	5✔
172	marker: PhantomData,	5✔
173	})	5✔
174	})	14✔
175	.map_err(LoadWithPersistError::InvalidChangeSet)	14✔
176	}	14✔
177
178	/// Persist staged changes of wallet into `persister`.
179	///
180	/// Returns whether any new changes were persisted.
181	///
182	/// If the `persister` errors, the staged changes will not be cleared.
183	pub fn persist(&mut self, persister: &mut P) -> Result<bool, P::Error> {	3✔
184	match self.inner.staged_mut() {	3✔
185	Some(stage) => {	3✔
186	P::persist(persister, &*stage)?;	3✔
187	let _ = stage.take();	3✔
188	Ok(true)	3✔
189	}
NEW 190	None => Ok(false),	×
191	}
192	}	3✔
193	}
194
195	/// Methods when `P` is an [`AsyncWalletPersister`].
196	impl<P: AsyncWalletPersister> PersistedWallet<P> {
197	/// Create a new [`PersistedWallet`] with the given async `persister` and `params`.
NEW 198	pub async fn create_async(	×
NEW 199	persister: &mut P,	×
NEW 200	params: CreateParams,	×
NEW 201	) -> Result<Self, CreateWithPersistError<P::Error>> {	×
NEW 202	let existing = P::initialize(persister)	×
NEW 203	.await	×
NEW 204	.map_err(CreateWithPersistError::Persist)?;	×
NEW 205	if !existing.is_empty() {	×
NEW 206	return Err(CreateWithPersistError::DataAlreadyExists(existing));	×
NEW 207	}	×
NEW 208	let mut inner =	×
NEW 209	Wallet::create_with_params(params).map_err(CreateWithPersistError::Descriptor)?;	×
NEW 210	if let Some(changeset) = inner.take_staged() {	×
NEW 211	P::persist(persister, &changeset)	×
NEW 212	.await	×
213	.map_err(CreateWithPersistError::Persist)?;	×
214	}	×
NEW 215	Ok(Self {	×
NEW 216	inner,	×
NEW 217	marker: PhantomData,	×
NEW 218	})	×
UNCOV 219	}	×
220
221	/// Load a previously [`PersistedWallet`] from the given async `persister` and `params`.
NEW 222	pub async fn load_async(	×
NEW 223	persister: &mut P,	×
NEW 224	params: LoadParams,	×
NEW 225	) -> Result<Option<Self>, LoadWithPersistError<P::Error>> {	×
NEW 226	let changeset = P::initialize(persister)	×
NEW 227	.await	×
NEW 228	.map_err(LoadWithPersistError::Persist)?;	×
NEW 229	Wallet::load_with_params(changeset, params)	×
NEW 230	.map(\|opt\| {	×
NEW 231	opt.map(\|inner\| PersistedWallet {	×
NEW 232	inner,	×
NEW 233	marker: PhantomData,	×
NEW 234	})	×
NEW 235	})	×
NEW 236	.map_err(LoadWithPersistError::InvalidChangeSet)	×
NEW 237	}	×
238
239	/// Persist staged changes of wallet into an async `persister`.
240	///
241	/// Returns whether any new changes were persisted.
242	///
243	/// If the `persister` errors, the staged changes will not be cleared.
NEW 244	pub async fn persist_async<'a>(&'a mut self, persister: &mut P) -> Result<bool, P::Error> {	×
NEW 245	match self.inner.staged_mut() {	×
NEW 246	Some(stage) => {	×
NEW 247	P::persist(persister, &*stage).await?;	×
NEW 248	let _ = stage.take();	×
NEW 249	Ok(true)	×
250	}
NEW 251	None => Ok(false),	×
252	}
UNCOV 253	}	×
254	}
255
256	#[cfg(feature = "rusqlite")]
257	impl<'c> WalletPersister for bdk_chain::rusqlite::Transaction<'c> {
258	type Error = bdk_chain::rusqlite::Error;
259
NEW 260	fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {	×
NEW 261	ChangeSet::init_sqlite_tables(&*persister)?;	×
NEW 262	ChangeSet::from_sqlite(persister)	×
NEW 263	}	×
264
NEW 265	fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {	×
NEW 266	changeset.persist_to_sqlite(persister)	×
UNCOV 267	}	×
268	}
269
270	#[cfg(feature = "rusqlite")]
271	impl WalletPersister for bdk_chain::rusqlite::Connection {
272	type Error = bdk_chain::rusqlite::Error;
273
274	fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {	104✔
275	let db_tx = persister.transaction()?;	104✔
276	ChangeSet::init_sqlite_tables(&db_tx)?;	104✔
277	let changeset = ChangeSet::from_sqlite(&db_tx)?;	104✔
278	db_tx.commit()?;	104✔
279	Ok(changeset)	104✔
280	}	104✔
281
282	fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {	56✔
283	let db_tx = persister.transaction()?;	56✔
284	changeset.persist_to_sqlite(&db_tx)?;	56✔
285	db_tx.commit()	56✔
286	}	56✔
287	}
288
289	/// Error for [`bdk_file_store`]'s implementation of [`WalletPersister`].
290	#[cfg(feature = "file_store")]
291	#[derive(Debug)]
292	pub enum FileStoreError {
293	/// Error when loading from the store.
294	Load(bdk_file_store::AggregateChangesetsError<ChangeSet>),
295	/// Error when writing to the store.
296	Write(std::io::Error),
297	}
298
299	#[cfg(feature = "file_store")]
300	impl core::fmt::Display for FileStoreError {
NEW 301	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {	×
NEW 302	use core::fmt::Display;	×
NEW 303	match self {	×
NEW 304	FileStoreError::Load(e) => Display::fmt(e, f),	×
NEW 305	FileStoreError::Write(e) => Display::fmt(e, f),	×
306	}
UNCOV 307	}	×
308	}
309
310	#[cfg(feature = "file_store")]
311	impl std::error::Error for FileStoreError {}
312
313	#[cfg(feature = "file_store")]
314	impl WalletPersister for bdk_file_store::Store<ChangeSet> {
315	type Error = FileStoreError;
316
317	fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {	64✔
318	persister	64✔
319	.aggregate_changesets()	64✔
320	.map(Option::unwrap_or_default)	64✔
321	.map_err(FileStoreError::Load)	64✔
322	}	64✔
323
324	fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {	24✔
325	persister	24✔
326	.append_changeset(changeset)	24✔
327	.map_err(FileStoreError::Write)	24✔
328	}	24✔
329	}
330
331	/// Error type for [`PersistedWallet::load`].
332	#[derive(Debug, PartialEq)]
333	pub enum LoadWithPersistError<E> {
334	/// Error from persistence.
335	Persist(E),
336	/// Occurs when the loaded changeset cannot construct [`Wallet`].
337	InvalidChangeSet(crate::LoadError),
338	}
339
340	impl<E: fmt::Display> fmt::Display for LoadWithPersistError<E> {
341	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {	×
342	match self {	×
343	Self::Persist(err) => fmt::Display::fmt(err, f),	×
344	Self::InvalidChangeSet(err) => fmt::Display::fmt(&err, f),	×
345	}
346	}	×
347	}
348
349	#[cfg(feature = "std")]
350	impl<E: fmt::Debug + fmt::Display> std::error::Error for LoadWithPersistError<E> {}
351
352	/// Error type for [`PersistedWallet::create`].
353	#[derive(Debug)]
354	pub enum CreateWithPersistError<E> {
355	/// Error from persistence.
356	Persist(E),
357	/// Persister already has wallet data.
358	DataAlreadyExists(ChangeSet),
359	/// Occurs when the loaded changeset cannot construct [`Wallet`].
360	Descriptor(DescriptorError),
361	}
362
363	impl<E: fmt::Display> fmt::Display for CreateWithPersistError<E> {
364	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {	×
365	match self {	×
366	Self::Persist(err) => fmt::Display::fmt(err, f),	×
NEW 367	Self::DataAlreadyExists(changeset) => write!(	×
NEW 368	f,	×
NEW 369	"Cannot create wallet in persister which already contains wallet data: {:?}",	×
NEW 370	changeset	×
NEW 371	),	×
UNCOV 372	Self::Descriptor(err) => fmt::Display::fmt(&err, f),	×
373	}
374	}	×
375	}
376
377	#[cfg(feature = "std")]
378	impl<E: fmt::Debug + fmt::Display> std::error::Error for CreateWithPersistError<E> {}

bitcoindevkit / bdk / 10456741773

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous