6884426202

Committed 16 Nov 2023 12:07AM UTC coverage: 81.24% (-0.1%) from 81.335%

Build # 6884426202

Build Type

push

github

Committed by

notmandatory

Commit Message

Merge bitcoindevkit/bdk#1178: `LocalChain` with hardwired genesis block

f1b112e8f docs(bitcoind_rpc): update docs for `Emitter::new` (志宇)
9a250baf6 chore: make clippy happy (志宇)
79b84bed0 feat(bdk): changeset's `Append` impl checks that network is consistent (志宇)
06a956ad2 feat!: change `load_from_persistence` to return an option (志宇)
c3265e251 test(bdk): add tests for wallet constructor methods (志宇)
96f1d94e2 test(file_store): add construction method tests (志宇)
1886dc4fe chore(examples): use `Wallet::new_or_load` method where appropriate (志宇)
24994a3ed feat(file_store)!: have separate methods for creating and opening Store (志宇)
d294e2e31 feat(wallet)!: add `new_or_load` methods (志宇)
7c6cbc4d9 chore(file_store): rm empty test file (志宇)
6cf3963c6 feat(bdk)!: have separate methods for creating and loading `Wallet` (志宇)
7d5f31f6c feat(chain, file_store): add `is_empty` method to `PersistBackend` trait (志宇)
5998a2281 feat!: `LocalChain` with hardwired genesis checkpoint (志宇)

Pull request description:

  closes #1079
  closes #1107

  ### Description

  Many methods of `TxGraph` require a `chain_tip: BlockId` input to use against a `ChainOracle` implementation. This is used to ask the `ChainOracle` implementation whether a certain block exists in the chain identified by the `chain_tip`. This guarantees that the `TxGraph` methods will return a consistent history of transactions.

  However, the `ChainOracle` trait's `get_chain_tip` method returns an option of `BlockId`. It becomes unclear what to do when `get_chain_tip` returns `None`.

  This PR changes the `... (continued)

Run Details

338 of 486 new or added lines in 9 files covered. (69.55%)

45 existing lines in 10 files now uncovered.

8782 of 10810 relevant lines covered (81.24%)

5816.41 hits per line

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

75.0

/crates/chain/src/persist.rs

use core::convert::Infallible;

use crate::Append;

/// `Persist` wraps a [`PersistBackend`] (`B`) to create a convenient staging area for changes (`C`)
/// before they are persisted.
///
/// Not all changes to the in-memory representation 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.
#[derive(Debug)]
pub struct Persist<B, C> {
    backend: B,
    stage: C,
}

impl<B, C> Persist<B, C>
where
    B: PersistBackend<C>,
    C: Default + Append,
{
    /// Create a new [`Persist`] from [`PersistBackend`].
    pub fn new(backend: B) -> Self {
        Self {
            backend,
            stage: Default::default(),
        }
    }

    /// Stage a `changeset` to be committed later with [`commit`].
    ///
    /// [`commit`]: Self::commit
    pub fn stage(&mut self, changeset: C) {
        self.stage.append(changeset)
    }

    /// Get the changes that have not been committed yet.
    pub fn staged(&self) -> &C {
        &self.stage
    }

    /// Commit the staged changes to the underlying persistence backend.
    ///
    /// Changes that are committed (if any) are returned.
    ///
    /// # Error
    ///
    /// Returns a backend-defined error if this fails.
    pub fn commit(&mut self) -> Result<Option<C>, B::WriteError> {
        if self.stage.is_empty() {
            return Ok(None);
        }
        self.backend
            .write_changes(&self.stage)
            // if written successfully, take and return `self.stage`
            .map(|_| Some(core::mem::take(&mut self.stage)))
    }
}

/// A persistence backend for [`Persist`].
///
/// `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 PersistBackend<C> {
    /// The error the backend returns when it fails to write.
    type WriteError: core::fmt::Debug;

    /// The error the backend returns when it fails to load changesets `C`.
    type LoadError: core::fmt::Debug;

    /// Writes a changeset to the persistence backend.
    ///
    /// It is up to the backend what it does with this. It could store every changeset in a list or
    /// it inserts the actual changes into a more structured database. All it needs to guarantee is
    /// that [`load_from_persistence`] restores a keychain tracker to what it should be if all
    /// changesets had been applied sequentially.
    ///
    /// [`load_from_persistence`]: Self::load_from_persistence
    fn write_changes(&mut self, changeset: &C) -> Result<(), Self::WriteError>;

    /// Return the aggregate changeset `C` from persistence.
    fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError>;
}

impl<C> PersistBackend<C> for () {
    type WriteError = Infallible;

    type LoadError = Infallible;

    fn write_changes(&mut self, _changeset: &C) -> Result<(), Self::WriteError> {
        Ok(())
    }

    fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError> {
        Ok(None)
    }
}

1	use core::convert::Infallible;
2
3	use crate::Append;
4
5	/// `Persist` wraps a [`PersistBackend`] (`B`) to create a convenient staging area for changes (`C`)
6	/// before they are persisted.
7	///
8	/// Not all changes to the in-memory representation needs to be written to disk right away, so
9	/// [`Persist::stage`] can be used to stage changes first and then [`Persist::commit`] can be used
10	/// to write changes to disk.
11	#[derive(Debug)]	×
12	pub struct Persist<B, C> {
13	backend: B,
14	stage: C,
15	}
16
17	impl<B, C> Persist<B, C>
18	where
19	B: PersistBackend<C>,
20	C: Default + Append,
21	{
22	/// Create a new [`Persist`] from [`PersistBackend`].
23	pub fn new(backend: B) -> Self {	150✔
24	Self {	150✔
25	backend,	150✔
26	stage: Default::default(),	150✔
27	}	150✔
28	}	150✔
29
30	/// Stage a `changeset` to be committed later with [`commit`].
31	///
32	/// [`commit`]: Self::commit
33	pub fn stage(&mut self, changeset: C) {	1,039✔
34	self.stage.append(changeset)	1,039✔
35	}	1,039✔
36
37	/// Get the changes that have not been committed yet.
38	pub fn staged(&self) -> &C {	×
39	&self.stage	×
40	}	×
41
42	/// Commit the staged changes to the underlying persistence backend.
43	///
44	/// Changes that are committed (if any) are returned.
45	///
46	/// # Error
47	///
48	/// Returns a backend-defined error if this fails.
49	pub fn commit(&mut self) -> Result<Option<C>, B::WriteError> {	479✔
50	if self.stage.is_empty() {	479✔
51	return Ok(None);	51✔
52	}	428✔
53	self.backend	428✔
54	.write_changes(&self.stage)	428✔
55	// if written successfully, take and return `self.stage`	428✔
56	.map(\|_\| Some(core::mem::take(&mut self.stage)))	428✔
57	}	479✔
58	}
59
60	/// A persistence backend for [`Persist`].
61	///
62	/// `C` represents the changeset; a datatype that records changes made to in-memory data structures
63	/// that are to be persisted, or retrieved from persistence.
64	pub trait PersistBackend<C> {
65	/// The error the backend returns when it fails to write.
66	type WriteError: core::fmt::Debug;
67
68	/// The error the backend returns when it fails to load changesets `C`.
69	type LoadError: core::fmt::Debug;
70
71	/// Writes a changeset to the persistence backend.
72	///
73	/// It is up to the backend what it does with this. It could store every changeset in a list or
74	/// it inserts the actual changes into a more structured database. All it needs to guarantee is
75	/// that [`load_from_persistence`] restores a keychain tracker to what it should be if all
76	/// changesets had been applied sequentially.
77	///
78	/// [`load_from_persistence`]: Self::load_from_persistence
79	fn write_changes(&mut self, changeset: &C) -> Result<(), Self::WriteError>;
80
81	/// Return the aggregate changeset `C` from persistence.
82	fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError>;
83	}
84
85	impl<C> PersistBackend<C> for () {
86	type WriteError = Infallible;
87
88	type LoadError = Infallible;
89
90	fn write_changes(&mut self, _changeset: &C) -> Result<(), Self::WriteError> {	426✔
91	Ok(())	426✔
92	}	426✔
93
NEW 94	fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError> {	×
NEW 95	Ok(None)	×
UNCOV 96	}	×
97	}

bitcoindevkit / bdk / 6884426202

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