chore: apply rustfmt

Author: luisschwab

crates/bitcoind_rpc/src/lib.rs

@@ -1,7 +1,8 @@
 //! This crate is used for emitting blockchain data from the `bitcoind` RPC interface. It does not
 //! use the wallet RPC API, so this crate can be used with wallet-disabled Bitcoin Core nodes.
 //!
-//! [`Emitter`] is the main structure which sources blockchain data from [`bitcoincore_rpc::Client`].
+//! [`Emitter`] is the main structure which sources blockchain data from
+//! [`bitcoincore_rpc::Client`].
 //!
 //! To only get block updates (exclude mempool transactions), the caller can use
 //! [`Emitter::next_block`] or/and [`Emitter::next_header`] until it returns `Ok(None)` (which means
@@ -153,8 +154,8 @@ pub struct BlockEvent<B> {
     /// The checkpoint of the new block.
     ///
     /// A [`CheckPoint`] is a node of a linked list of [`BlockId`]s. This checkpoint is linked to
-    /// all [`BlockId`]s originally passed in [`Emitter::new`] as well as emitted blocks since then.
-    /// These blocks are guaranteed to be of the same chain.
+    /// all [`BlockId`]s originally passed in [`Emitter::new`] as well as emitted blocks since
+    /// then. These blocks are guaranteed to be of the same chain.
     ///
     /// This is important as BDK structures require block-to-apply to be connected with another
     /// block in the original chain.

crates/chain/src/indexed_tx_graph.rs

@@ -95,7 +95,8 @@ where
 
     /// Apply an `update` directly.
     ///
-    /// `update` is a [`tx_graph::TxUpdate<A>`] and the resultant changes is returned as [`ChangeSet`].
+    /// `update` is a [`tx_graph::TxUpdate<A>`] and the resultant changes is returned as
+    /// [`ChangeSet`].
     pub fn apply_update(&mut self, update: tx_graph::TxUpdate<A>) -> ChangeSet<A, I::ChangeSet> {
         let tx_graph = self.graph.apply_update(update);
         let indexer = self.index_tx_graph_changeset(&tx_graph);
@@ -325,7 +326,9 @@ where
 {
     /// List txids that are expected to exist under the given spks.
     ///
-    /// This is used to fill [`SyncRequestBuilder::expected_spk_txids`](bdk_core::spk_client::SyncRequestBuilder::expected_spk_txids).
+    /// This is used to fill
+    /// [`SyncRequestBuilder::expected_spk_txids`](bdk_core::spk_client::SyncRequestBuilder::expected_spk_txids).
+    ///
     ///
     /// The spk index range can be contrained with `range`.
     ///

crates/chain/src/indexer/keychain_txout.rs

@@ -70,8 +70,8 @@ pub const DEFAULT_LOOKAHEAD: u32 = 25;
 ///
 /// # Change sets
 ///
-/// Methods that can update the last revealed index or add keychains will return [`ChangeSet`] to report
-/// these changes. This should be persisted for future recovery.
+/// Methods that can update the last revealed index or add keychains will return [`ChangeSet`] to
+/// report these changes. This should be persisted for future recovery.
 ///
 /// ## Synopsis
 ///
@@ -569,8 +569,8 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
             .map(|((_, i), spk)| (*i, spk))
     }
 
-    /// Get the next derivation index for `keychain`. The next index is the index after the last revealed
-    /// derivation index.
+    /// Get the next derivation index for `keychain`. The next index is the index after the last
+    /// revealed derivation index.
     ///
     /// The second field in the returned tuple represents whether the next derivation index is new.
     /// There are two scenarios where the next derivation index is reused (not new):
@@ -708,8 +708,8 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
     /// This will derive and reveal a new script pubkey if no more unused script pubkeys exist.
     ///
     /// If the descriptor has no wildcard and already has a used script pubkey or if a descriptor
-    /// has used all scripts up to the derivation bounds, then the last derived script pubkey will be
-    /// returned.
+    /// has used all scripts up to the derivation bounds, then the last derived script pubkey will
+    /// be returned.
     ///
     /// Returns `None` if there are no script pubkeys that have been used and no new script pubkey
     /// could be revealed (see [`reveal_next_spk`] for when this happens).

crates/chain/src/indexer/spk_txout.rs

@@ -1,4 +1,5 @@
-//! [`SpkTxOutIndex`] is an index storing [`TxOut`]s that have a script pubkey that matches those in a list.
+//! [`SpkTxOutIndex`] is an index storing [`TxOut`]s that have a script pubkey that matches those in
+//! a list.
 
 use core::ops::RangeBounds;
 
@@ -15,14 +16,14 @@ use bitcoin::{Amount, OutPoint, ScriptBuf, SignedAmount, Transaction, TxOut, Txi
 /// index will look at any txouts you pass in and store and index any txouts matching one of its
 /// script pubkeys.
 ///
-/// Each script pubkey is associated with an application-defined index script index `I`, which must be
-/// [`Ord`]. Usually, this is used to associate the derivation index of the script pubkey or even a
-/// combination of `(keychain, derivation_index)`.
+/// Each script pubkey is associated with an application-defined index script index `I`, which must
+/// be [`Ord`]. Usually, this is used to associate the derivation index of the script pubkey or even
+/// a combination of `(keychain, derivation_index)`.
 ///
 /// Note there is no harm in scanning transactions that disappear from the blockchain or were never
 /// in there in the first place. `SpkTxOutIndex` is intentionally *monotone* -- you cannot delete or
-/// modify txouts that have been indexed. To find out which txouts from the index are actually in the
-/// chain or unspent, you must use other sources of information like a [`TxGraph`].
+/// modify txouts that have been indexed. To find out which txouts from the index are actually in
+/// the chain or unspent, you must use other sources of information like a [`TxGraph`].
 ///
 /// [`TxOut`]: bitcoin::TxOut
 /// [`insert_spk`]: Self::insert_spk
@@ -89,9 +90,10 @@ impl<I: Clone + Ord + core::fmt::Debug> SpkTxOutIndex<I> {
     ///
     /// Typically, this is used in two situations:
     ///
-    /// 1. After loading transaction data from the disk, you may scan over all the txouts to restore all
-    ///    your txouts.
-    /// 2. When getting new data from the chain, you usually scan it before incorporating it into your chain state.
+    /// 1. After loading transaction data from the disk, you may scan over all the txouts to restore
+    ///    all your txouts.
+    /// 2. When getting new data from the chain, you usually scan it before incorporating it into
+    ///    your chain state.
     pub fn scan(&mut self, tx: &Transaction) -> BTreeSet<I> {
         let mut scanned_indices = BTreeSet::new();
         let txid = tx.compute_txid();
@@ -191,7 +193,8 @@ impl<I: Clone + Ord + core::fmt::Debug> SpkTxOutIndex<I> {
         &self.spks
     }
 
-    /// Adds a script pubkey to scan for. Returns `false` and does nothing if spk already exists in the map
+    /// Adds a script pubkey to scan for. Returns `false` and does nothing if spk already exists in
+    /// the map
     ///
     /// the index will look for outputs spending to this spk whenever it scans new data.
     pub fn insert_spk(&mut self, index: I, spk: ScriptBuf) -> bool {
@@ -243,14 +246,14 @@ impl<I: Clone + Ord + core::fmt::Debug> SpkTxOutIndex<I> {
         !self.unused.contains(index)
     }
 
-    /// Marks the script pubkey at `index` as used even though it hasn't seen an output spending to it.
-    /// This only affects when the `index` had already been added to `self` and was unused.
+    /// Marks the script pubkey at `index` as used even though it hasn't seen an output spending to
+    /// it. This only affects when the `index` had already been added to `self` and was unused.
     ///
     /// Returns whether the `index` was initially present as `unused`.
     ///
     /// This is useful when you want to reserve a script pubkey for something but don't want to add
-    /// the transaction output using it to the index yet. Other callers will consider the `index` used
-    /// until you call [`unmark_used`].
+    /// the transaction output using it to the index yet. Other callers will consider the `index`
+    /// used until you call [`unmark_used`].
     ///
     /// [`unmark_used`]: Self::unmark_used
     pub fn mark_used(&mut self, index: &I) -> bool {
@@ -326,8 +329,8 @@ impl<I: Clone + Ord + core::fmt::Debug> SpkTxOutIndex<I> {
     /// matches one of our script pubkeys.
     ///
     /// It is easily possible to misuse this method and get false negatives by calling it before you
-    /// have scanned the `TxOut`s the transaction is spending. For example, if you want to filter out
-    /// all the transactions in a block that are irrelevant, you **must first scan all the
+    /// have scanned the `TxOut`s the transaction is spending. For example, if you want to filter
+    /// out all the transactions in a block that are irrelevant, you **must first scan all the
     /// transactions in the block** and only then use this method.
     pub fn is_relevant(&self, tx: &Transaction) -> bool {
         let input_matches = tx

crates/chain/src/lib.rs

@@ -9,11 +9,11 @@
 //! Our design goals for these mechanisms are:
 //!
 //! 1. Data source agnostic -- nothing in `bdk_chain` cares about where you get data from or whether
-//!    you do it synchronously or asynchronously. If you know a fact about the blockchain, you can just
-//!    tell `bdk_chain`'s APIs about it, and that information will be integrated, if it can be done
-//!    consistently.
-//! 2. Data persistence agnostic -- `bdk_chain` does not care where you cache on-chain data, what you
-//!    cache or how you retrieve it from persistent storage.
+//!    you do it synchronously or asynchronously. If you know a fact about the blockchain, you can
+//!    just tell `bdk_chain`'s APIs about it, and that information will be integrated, if it can be
+//!    done consistently.
+//! 2. Data persistence agnostic -- `bdk_chain` does not care where you cache on-chain data, what
+//!    you cache or how you retrieve it from persistent storage.
 //!
 //! [Bitcoin Dev Kit]: https://bitcoindevkit.org/
 

crates/chain/src/local_chain.rs

@@ -178,7 +178,8 @@ impl LocalChain {
         Ok(changeset)
     }
 
-    /// Update the chain with a given [`Header`] at `height` which you claim is connected to a existing block in the chain.
+    /// Update the chain with a given [`Header`] at `height` which you claim is connected to a
+    /// existing block in the chain.
     ///
     /// This is useful when you have a block header that you want to record as part of the chain but
     /// don't necessarily know that the `prev_blockhash` is in the chain.
@@ -410,8 +411,8 @@ impl LocalChain {
 pub struct ChangeSet {
     /// Changes to the [`LocalChain`] blocks.
     ///
-    /// The key represents the block height, and the value either represents added a new [`CheckPoint`]
-    /// (if [`Some`]), or removing a [`CheckPoint`] (if [`None`]).
+    /// The key represents the block height, and the value either represents added a new
+    /// [`CheckPoint`] (if [`Some`]), or removing a [`CheckPoint`] (if [`None`]).
     pub blocks: BTreeMap<u32, Option<BlockHash>>,
 }
 
@@ -605,9 +606,10 @@ fn merge_chains(
                 if o.hash() == u.hash() {
                     // We have found our point of agreement 🎉 -- we require that the previous (i.e.
                     // higher because we are iterating backwards) block in the original chain was
-                    // invalidated (if it exists). This ensures that there is an unambiguous point of
-                    // connection to the original chain from the update chain (i.e. we know the
-                    // precisely which original blocks are invalid).
+                    // invalidated (if it exists). This ensures that there is an unambiguous point
+                    // of connection to the original chain from the update chain
+                    // (i.e. we know the precisely which original blocks are
+                    // invalid).
                     if !prev_orig_was_invalidated && !point_of_agreement_found {
                         if let (Some(prev_orig), Some(_prev_update)) = (&prev_orig, &prev_update) {
                             return Err(CannotConnectError {

crates/chain/src/spk_iter.rs

@@ -11,8 +11,8 @@ pub const BIP32_MAX_INDEX: u32 = (1 << 31) - 1;
 /// An iterator for derived script pubkeys.
 ///
 /// [`SpkIterator`] is an implementation of the [`Iterator`] trait which possesses its own `next()`
-/// and `nth()` functions, both of which circumvent the unnecessary intermediate derivations required
-/// when using their default implementations.
+/// and `nth()` functions, both of which circumvent the unnecessary intermediate derivations
+/// required when using their default implementations.
 ///
 /// ## Examples
 ///
@@ -101,8 +101,8 @@ where
     type Item = Indexed<ScriptBuf>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        // For non-wildcard descriptors, we expect the first element to be Some((0, spk)), then None after.
-        // For wildcard descriptors, we expect it to keep iterating until exhausted.
+        // For non-wildcard descriptors, we expect the first element to be Some((0, spk)), then None
+        // after. For wildcard descriptors, we expect it to keep iterating until exhausted.
         if self.next_index >= self.end {
             return None;
         }

crates/chain/src/tx_graph.rs

@@ -23,13 +23,13 @@
 //!
 //! * [`list_canonical_txs`](TxGraph::list_canonical_txs) lists canonical transactions.
 //! * [`filter_chain_txouts`](TxGraph::filter_chain_txouts) filters out canonical outputs from a
-//!     list of outpoints.
+//!   list of outpoints.
 //! * [`filter_chain_unspents`](TxGraph::filter_chain_unspents) filters out canonical unspent
-//!     outputs from a list of outpoints.
+//!   outputs from a list of outpoints.
 //! * [`balance`](TxGraph::balance) gets the total sum of unspent outputs filtered from a list of
-//!     outpoints.
+//!   outpoints.
 //! * [`canonical_iter`](TxGraph::canonical_iter) returns the [`CanonicalIter`] which contains all
-//!     of the canonicalization logic.
+//!   of the canonicalization logic.
 //!
 //! All these methods require a `chain` and `chain_tip` argument. The `chain` must be a
 //! [`ChainOracle`] implementation (such as [`LocalChain`](crate::local_chain::LocalChain)) which
@@ -39,17 +39,17 @@
 //! transactions have precedence over others:
 //!
 //! * [`Anchor`] - This bit of data represents that a transaction is anchored in a given block. If
-//!     the transaction is anchored in chain of `chain_tip`, or is an ancestor of a transaction
-//!     anchored in chain of `chain_tip`, then the transaction must be canonical.
+//!   the transaction is anchored in chain of `chain_tip`, or is an ancestor of a transaction
+//!   anchored in chain of `chain_tip`, then the transaction must be canonical.
 //! * `last_seen` - This is the timestamp of when a transaction is last-seen in the mempool. This
-//!     value is updated by [`insert_seen_at`](TxGraph::insert_seen_at) and
-//!     [`apply_update`](TxGraph::apply_update). Transactions that are seen later have higher
-//!     priority than those that are seen earlier. `last_seen` values are transitive. This means
-//!     that the actual `last_seen` value of a transaction is the max of all the `last_seen` values
-//!     from it's descendants.
+//!   value is updated by [`insert_seen_at`](TxGraph::insert_seen_at) and
+//!   [`apply_update`](TxGraph::apply_update). Transactions that are seen later have higher priority
+//!   than those that are seen earlier. `last_seen` values are transitive. This means that the
+//!   actual `last_seen` value of a transaction is the max of all the `last_seen` values from it's
+//!   descendants.
 //! * `last_evicted` - This is the timestamp of when a transaction last went missing from the
-//!     mempool. If this value is equal to or higher than the transaction's `last_seen` value, then
-//!     it will not be considered canonical.
+//!   mempool. If this value is equal to or higher than the transaction's `last_seen` value, then it
+//!   will not be considered canonical.
 //!
 //! # Graph traversal
 //!
@@ -392,13 +392,13 @@ impl<A> TxGraph<A> {
         })
     }
 
-    /// Calculates the fee of a given transaction. Returns [`Amount::ZERO`] if `tx` is a coinbase transaction.
-    /// Returns `OK(_)` if we have all the [`TxOut`]s being spent by `tx` in the graph (either as
-    /// the full transactions or individual txouts).
+    /// Calculates the fee of a given transaction. Returns [`Amount::ZERO`] if `tx` is a coinbase
+    /// transaction. Returns `OK(_)` if we have all the [`TxOut`]s being spent by `tx` in the
+    /// graph (either as the full transactions or individual txouts).
     ///
     /// To calculate the fee for a [`Transaction`] that depends on foreign [`TxOut`] values you must
-    /// first manually insert the foreign TxOuts into the tx graph using the [`insert_txout`] function.
-    /// Only insert TxOuts you trust the values for!
+    /// first manually insert the foreign TxOuts into the tx graph using the [`insert_txout`]
+    /// function. Only insert TxOuts you trust the values for!
     ///
     /// Note `tx` does not have to be in the graph for this to work.
     ///
@@ -471,7 +471,7 @@ impl<A: Clone + Ord> TxGraph<A> {
     /// The supplied closure takes in two inputs `(depth, ancestor_tx)`:
     ///
     /// * `depth` is the distance between the starting `Transaction` and the `ancestor_tx`. I.e., if
-    ///    the `Transaction` is spending an output of the `ancestor_tx` then `depth` will be 1.
+    ///   the `Transaction` is spending an output of the `ancestor_tx` then `depth` will be 1.
     /// * `ancestor_tx` is the `Transaction`'s ancestor which we are considering to walk.
     ///
     /// The supplied closure returns an `Option<T>`, allowing the caller to map each `Transaction`
@@ -488,8 +488,8 @@ impl<A: Clone + Ord> TxGraph<A> {
     ///
     /// The supplied closure takes in two inputs `(depth, descendant_txid)`:
     ///
-    /// * `depth` is the distance between the starting `txid` and the `descendant_txid`. I.e., if the
-    ///     descendant is spending an output of the starting `txid` then `depth` will be 1.
+    /// * `depth` is the distance between the starting `txid` and the `descendant_txid`. I.e., if
+    ///   the descendant is spending an output of the starting `txid` then `depth` will be 1.
     /// * `descendant_txid` is the descendant's txid which we are considering to walk.
     ///
     /// The supplied closure returns an `Option<T>`, allowing the caller to map each node it visits
@@ -779,8 +779,8 @@ impl<A: Anchor> TxGraph<A> {
 
     /// Extends this graph with the given `update`.
     ///
-    /// The returned [`ChangeSet`] is the set difference between `update` and `self` (transactions that
-    /// exist in `update` but not in `self`).
+    /// The returned [`ChangeSet`] is the set difference between `update` and `self` (transactions
+    /// that exist in `update` but not in `self`).
     pub fn apply_update(&mut self, update: TxUpdate<A>) -> ChangeSet<A> {
         let mut changeset = ChangeSet::<A>::default();
         for tx in update.txs {
@@ -1158,7 +1158,9 @@ impl<A: Anchor> TxGraph<A> {
 
     /// List txids that are expected to exist under the given spks.
     ///
-    /// This is used to fill [`SyncRequestBuilder::expected_spk_txids`](bdk_core::spk_client::SyncRequestBuilder::expected_spk_txids).
+    /// This is used to fill
+    /// [`SyncRequestBuilder::expected_spk_txids`](bdk_core::spk_client::SyncRequestBuilder::expected_spk_txids).
+    ///
     ///
     /// The spk index range can be constrained with `range`.
     ///