frost/bdk
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge bitcoindevkit/bdk#1502: chore(chain)!: Rename Append to Merge

Browse Source 
962305f41546613b5b41b4131d4a5594f01a2de0 chore(chain)!: Rename `Append` to `Merge` (Wei Chen)

Pull request description:

  <!-- You can erase any parts of this template not applicable to your Pull Request. -->
  Fixes #1467.

  ### Description

  <!-- Describe the purpose of this PR, what's being adding and/or fixed -->
  Renames the `Append` trait to `Merge`.

  ### Notes to the reviewers

  <!-- In this section you can include notes directed to the reviewers, like explaining why some parts
  of the PR were done in a specific way -->

  ### Changelog notice

  <!-- Notice the release manager should include in the release tag message changelog -->
  <!-- See https://keepachangelog.com/en/1.0.0/ for examples -->
  * Rename `bdk_chain::Append` to `bdk_chain::Merge`.

  ### Checklists

  #### All Submissions:

  * [x] I've signed all my commits
  * [x] I followed the [contribution guidelines](https://github.com/bitcoindevkit/bdk/blob/master/CONTRIBUTING.md)
  * [x] I ran `cargo fmt` and `cargo clippy` before committing

ACKs for top commit:
  notmandatory:
    ACK 962305f41546613b5b41b4131d4a5594f01a2de0

Tree-SHA512: 2019d9ed631776850cda39c9a53bdd3660c7f4715d8c418824d8ad13718f2b2fd160159e03fd63743dbf0b9e91cfdfed7e4cd4a591636f67d2aaec419486d136
This commit is contained in:
Steve Myers 2024-07-07 20:49:01 -05:00
commit 43f093d918
No known key found for this signature in database
GPG Key ID: 8105A46B22C2D051
16 changed files with 117 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/bitcoind_rpc/tests/test_emitter.rs
View File

@ -4,7 +4,7 @@ use bdk_bitcoind_rpc::Emitter;
use bdk_chain::{
bitcoin::{Address, Amount, Txid},
local_chain::{CheckPoint, LocalChain},
Append, Balance, BlockId, IndexedTxGraph, SpkTxOutIndex,
Balance, BlockId, IndexedTxGraph, Merge, SpkTxOutIndex,
};
use bdk_testenv::{anyhow, TestEnv};
use bitcoin::{hashes::Hash, Block, OutPoint, ScriptBuf, WScriptHash};

8
crates/chain/src/changeset.rs
View File

@ -34,10 +34,10 @@ impl<K, A> core::default::Default for CombinedChangeSet<K, A> {
}
#[cfg(feature = "miniscript")]
impl<K: Ord, A: crate::Anchor> crate::Append for CombinedChangeSet<K, A> {
fn append(&mut self, other: Self) {
crate::Append::append(&mut self.chain, other.chain);
crate::Append::append(&mut self.indexed_tx_graph, other.indexed_tx_graph);
impl<K: Ord, A: crate::Anchor> crate::Merge for CombinedChangeSet<K, A> {
fn merge(&mut self, other: Self) {
crate::Merge::merge(&mut self.chain, other.chain);
crate::Merge::merge(&mut self.indexed_tx_graph, other.indexed_tx_graph);
if other.network.is_some() {
debug_assert!(
self.network.is_none() || self.network == other.network,

36
crates/chain/src/indexed_tx_graph.rs
View File

@ -5,7 +5,7 @@ use bitcoin::{Block, OutPoint, Transaction, TxOut, Txid};
use crate::{
tx_graph::{self, TxGraph},
Anchor, AnchorFromBlockPosition, Append, BlockId, Indexer,
Anchor, AnchorFromBlockPosition, BlockId, Indexer, Merge,
};
/// The [`IndexedTxGraph`] combines a [`TxGraph`] and an [`Indexer`] implementation.
@ -67,7 +67,7 @@ impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I> {
impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
where
I::ChangeSet: Default + Append,
I::ChangeSet: Default + Merge,
{
fn index_tx_graph_changeset(
&mut self,
@ -75,10 +75,10 @@ where
) -> I::ChangeSet {
let mut changeset = I::ChangeSet::default();
for added_tx in &tx_graph_changeset.txs {
changeset.append(self.index.index_tx(added_tx));
changeset.merge(self.index.index_tx(added_tx));
}
for (&added_outpoint, added_txout) in &tx_graph_changeset.txouts {
changeset.append(self.index.index_txout(added_outpoint, added_txout));
changeset.merge(self.index.index_txout(added_outpoint, added_txout));
}
changeset
}
@ -137,16 +137,16 @@ where
let mut indexer = I::ChangeSet::default();
for (tx, _) in &txs {
indexer.append(self.index.index_tx(tx));
indexer.merge(self.index.index_tx(tx));
}
let mut graph = tx_graph::ChangeSet::default();
for (tx, anchors) in txs {
if self.index.is_tx_relevant(tx) {
let txid = tx.compute_txid();
graph.append(self.graph.insert_tx(tx.clone()));
graph.merge(self.graph.insert_tx(tx.clone()));
for anchor in anchors {
graph.append(self.graph.insert_anchor(txid, anchor));
graph.merge(self.graph.insert_anchor(txid, anchor));
}
}
}
@ -176,7 +176,7 @@ where
let mut indexer = I::ChangeSet::default();
for (tx, _) in &txs {
indexer.append(self.index.index_tx(tx));
indexer.merge(self.index.index_tx(tx));
}
let graph = self.graph.batch_insert_unconfirmed(
@ -210,7 +210,7 @@ where
/// Methods are available if the anchor (`A`) implements [`AnchorFromBlockPosition`].
impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
where
I::ChangeSet: Default + Append,
I::ChangeSet: Default + Merge,
A: AnchorFromBlockPosition,
{
/// Batch insert all transactions of the given `block` of `height`, filtering out those that are
@ -232,14 +232,14 @@ where
};
let mut changeset = ChangeSet::<A, I::ChangeSet>::default();
for (tx_pos, tx) in block.txdata.iter().enumerate() {
changeset.indexer.append(self.index.index_tx(tx));
changeset.indexer.merge(self.index.index_tx(tx));
if self.index.is_tx_relevant(tx) {
let txid = tx.compute_txid();
let anchor = A::from_block_position(block, block_id, tx_pos);
changeset.graph.append(self.graph.insert_tx(tx.clone()));
changeset.graph.merge(self.graph.insert_tx(tx.clone()));
changeset
.graph
.append(self.graph.insert_anchor(txid, anchor));
.merge(self.graph.insert_anchor(txid, anchor));
}
}
changeset
@ -261,8 +261,8 @@ where
let mut graph = tx_graph::ChangeSet::default();
for (tx_pos, tx) in block.txdata.iter().enumerate() {
let anchor = A::from_block_position(&block, block_id, tx_pos);
graph.append(self.graph.insert_anchor(tx.compute_txid(), anchor));
graph.append(self.graph.insert_tx(tx.clone()));
graph.merge(self.graph.insert_anchor(tx.compute_txid(), anchor));
graph.merge(self.graph.insert_tx(tx.clone()));
}
let indexer = self.index_tx_graph_changeset(&graph);
ChangeSet { graph, indexer }
@ -299,10 +299,10 @@ impl<A, IA: Default> Default for ChangeSet<A, IA> {
}
}
impl<A: Anchor, IA: Append> Append for ChangeSet<A, IA> {
fn append(&mut self, other: Self) {
self.graph.append(other.graph);
self.indexer.append(other.indexer);
impl<A: Anchor, IA: Merge> Merge for ChangeSet<A, IA> {
fn merge(&mut self, other: Self) {
self.graph.merge(other.graph);
self.indexer.merge(other.indexer);
}
fn is_empty(&self) -> bool {

16
crates/chain/src/indexer/keychain_txout.rs
View File

@ -14,7 +14,7 @@ use core::{
ops::{Bound, RangeBounds},
};
use crate::Append;
use crate::Merge;
/// The default lookahead for a [`KeychainTxOutIndex`]
pub const DEFAULT_LOOKAHEAD: u32 = 25;
@ -157,7 +157,7 @@ impl<K: Clone + Ord + Debug> Indexer for KeychainTxOutIndex<K> {
let mut changeset = ChangeSet::<K>::default();
let txid = tx.compute_txid();
for (op, txout) in tx.output.iter().enumerate() {
changeset.append(self.index_txout(OutPoint::new(txid, op as u32), txout));
changeset.merge(self.index_txout(OutPoint::new(txid, op as u32), txout));
}
changeset
}
@ -632,7 +632,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
for (keychain, &index) in keychains {
if let Some((_, new_changeset)) = self.reveal_to_target(keychain, index) {
changeset.append(new_changeset);
changeset.merge(new_changeset);
}
}
@ -666,7 +666,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
match self.reveal_next_spk(keychain) {
Some(((i, spk), change)) => {
spks.push((i, spk));
changeset.append(change);
changeset.merge(change);
}
None => break,
}
@ -856,12 +856,12 @@ impl<K: core::fmt::Debug> std::error::Error for InsertDescriptorError<K> {}
///
/// It can be applied to [`KeychainTxOutIndex`] with [`apply_changeset`].
///
/// The `last_revealed` field is monotone in that [`append`] will never decrease it.
/// The `last_revealed` field is monotone in that [`merge`] will never decrease it.
/// `keychains_added` is *not* monotone, once it is set any attempt to change it is subject to the
/// same *one-to-one* keychain <-> descriptor mapping invariant as [`KeychainTxOutIndex`] itself.
///
/// [`apply_changeset`]: KeychainTxOutIndex::apply_changeset
/// [`append`]: Self::append
/// [`Merge`]: Self::merge
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(
feature = "serde",
@ -882,14 +882,14 @@ pub struct ChangeSet<K> {
pub last_revealed: BTreeMap<DescriptorId, u32>,
}
impl<K: Ord> Append for ChangeSet<K> {
impl<K: Ord> Merge for ChangeSet<K> {
/// Merge another [`ChangeSet<K>`] into self.
///
/// For the `keychains_added` field this method respects the invariants of
/// [`insert_descriptor`]. `last_revealed` always becomes the larger of the two.
///
/// [`insert_descriptor`]: KeychainTxOutIndex::insert_descriptor
fn append(&mut self, other: Self) {
fn merge(&mut self, other: Self) {
for (new_keychain, new_descriptor) in other.keychains_added {
// enforce 1-to-1 invariance
if !self.keychains_added.contains_key(&new_keychain)

54
crates/chain/src/tx_data_traits.rs
View File

@ -113,10 +113,10 @@ pub trait AnchorFromBlockPosition: Anchor {
fn from_block_position(block: &bitcoin::Block, block_id: BlockId, tx_pos: usize) -> Self;
}
/// Trait that makes an object appendable.
pub trait Append: Default {
/// Append another object of the same type onto `self`.
fn append(&mut self, other: Self);
/// Trait that makes an object mergeable.
pub trait Merge: Default {
/// Merge another object of the same type onto `self`.
fn merge(&mut self, other: Self);
/// Returns whether the structure is considered empty.
fn is_empty(&self) -> bool;
@ -131,8 +131,8 @@ pub trait Append: Default {
}
}
impl<K: Ord, V> Append for BTreeMap<K, V> {
fn append(&mut self, other: Self) {
impl<K: Ord, V> Merge for BTreeMap<K, V> {
fn merge(&mut self, other: Self) {
// We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
// Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
BTreeMap::extend(self, other)
@ -143,8 +143,8 @@ impl<K: Ord, V> Append for BTreeMap<K, V> {
}
}
impl<T: Ord> Append for BTreeSet<T> {
fn append(&mut self, other: Self) {
impl<T: Ord> Merge for BTreeSet<T> {
fn merge(&mut self, other: Self) {
// We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
// Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
BTreeSet::extend(self, other)
@ -155,8 +155,8 @@ impl<T: Ord> Append for BTreeSet<T> {
}
}
impl<T> Append for Vec<T> {
fn append(&mut self, mut other: Self) {
impl<T> Merge for Vec<T> {
fn merge(&mut self, mut other: Self) {
Vec::append(self, &mut other)
}
@ -165,30 +165,30 @@ impl<T> Append for Vec<T> {
}
}
macro_rules! impl_append_for_tuple {
macro_rules! impl_merge_for_tuple {
($($a:ident $b:tt)*) => {
impl<$($a),*> Append for ($($a,)*) where $($a: Append),* {
impl<$($a),*> Merge for ($($a,)*) where $($a: Merge),* {
fn append(&mut self, _other: Self) {
$(Append::append(&mut self.$b, _other.$b) );*
fn merge(&mut self, _other: Self) {
$(Merge::merge(&mut self.$b, _other.$b) );*
}
fn is_empty(&self) -> bool {
$(Append::is_empty(&self.$b) && )* true
$(Merge::is_empty(&self.$b) && )* true
}
}
}
}
impl_append_for_tuple!();
impl_append_for_tuple!(T0 0);
impl_append_for_tuple!(T0 0 T1 1);
impl_append_for_tuple!(T0 0 T1 1 T2 2);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7 T8 8);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7 T8 8 T9 9);
impl_append_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7 T8 8 T9 9 T10 10);
impl_merge_for_tuple!();
impl_merge_for_tuple!(T0 0);
impl_merge_for_tuple!(T0 0 T1 1);
impl_merge_for_tuple!(T0 0 T1 1 T2 2);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7 T8 8);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7 T8 8 T9 9);
impl_merge_for_tuple!(T0 0 T1 1 T2 2 T3 3 T4 4 T5 5 T6 6 T7 7 T8 8 T9 9 T10 10);

14
crates/chain/src/tx_graph.rs
View File

@ -69,7 +69,7 @@
//! A [`TxGraph`] can also be updated with another [`TxGraph`] which merges them together.
//!
//! ```
//! # use bdk_chain::{Append, BlockId};
//! # use bdk_chain::{Merge, BlockId};
//! # use bdk_chain::tx_graph::TxGraph;
//! # use bdk_chain::example_utils::*;
//! # use bitcoin::Transaction;
@ -89,7 +89,7 @@
//! [`insert_txout`]: TxGraph::insert_txout
use crate::{
collections::*, Anchor, Append, Balance, BlockId, ChainOracle, ChainPosition, FullTxOut,
collections::*, Anchor, Balance, BlockId, ChainOracle, ChainPosition, FullTxOut, Merge,
};
use alloc::collections::vec_deque::VecDeque;
use alloc::sync::Arc;
@ -547,8 +547,8 @@ impl<A: Clone + Ord> TxGraph<A> {
) -> ChangeSet<A> {
let mut changeset = ChangeSet::<A>::default();
for (tx, seen_at) in txs {
changeset.append(self.insert_seen_at(tx.compute_txid(), seen_at));
changeset.append(self.insert_tx(tx));
changeset.merge(self.insert_seen_at(tx.compute_txid(), seen_at));
changeset.merge(self.insert_tx(tx));
}
changeset
}
@ -630,7 +630,7 @@ impl<A: Clone + Ord> TxGraph<A> {
.collect();
for txid in unanchored_txs {
changeset.append(self.insert_seen_at(txid, seen_at));
changeset.merge(self.insert_seen_at(txid, seen_at));
}
changeset
}
@ -1293,8 +1293,8 @@ impl<A> ChangeSet<A> {
}
}
impl<A: Ord> Append for ChangeSet<A> {
fn append(&mut self, other: Self) {
impl<A: Ord> Merge for ChangeSet<A> {
fn merge(&mut self, other: Self) {
// We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
// Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
self.txs.extend(other.txs);

2
crates/chain/tests/test_indexed_tx_graph.rs
View File

@ -10,7 +10,7 @@ use bdk_chain::{
indexed_tx_graph::{self, IndexedTxGraph},
indexer::keychain_txout::KeychainTxOutIndex,
local_chain::LocalChain,
tx_graph, Append, Balance, ChainPosition, ConfirmationHeightAnchor, DescriptorExt,
tx_graph, Balance, ChainPosition, ConfirmationHeightAnchor, DescriptorExt, Merge,
};
use bitcoin::{
secp256k1::Secp256k1, Amount, OutPoint, Script, ScriptBuf, Transaction, TxIn, TxOut,

10
crates/chain/tests/test_keychain_txout_index.rs
View File

@ -5,7 +5,7 @@ mod common;
use bdk_chain::{
collections::BTreeMap,
indexer::keychain_txout::{ChangeSet, KeychainTxOutIndex},
Append, DescriptorExt, DescriptorId, Indexer,
DescriptorExt, DescriptorId, Indexer, Merge,
};
use bitcoin::{secp256k1::Secp256k1, Amount, OutPoint, ScriptBuf, Transaction, TxOut};
@ -51,13 +51,13 @@ fn spk_at_index(descriptor: &Descriptor<DescriptorPublicKey>, index: u32) -> Scr
}
// We create two empty changesets lhs and rhs, we then insert various descriptors with various
// last_revealed, append rhs to lhs, and check that the result is consistent with these rules:
// last_revealed, merge rhs to lhs, and check that the result is consistent with these rules:
// - Existing index doesn't update if the new index in `other` is lower than `self`.
// - Existing index updates if the new index in `other` is higher than `self`.
// - Existing index is unchanged if keychain doesn't exist in `other`.
// - New keychain gets added if the keychain is in `other` but not in `self`.
#[test]
fn append_changesets_check_last_revealed() {
fn merge_changesets_check_last_revealed() {
let secp = bitcoin::secp256k1::Secp256k1::signing_only();
let descriptor_ids: Vec<_> = DESCRIPTORS
.iter()
@ -88,7 +88,7 @@ fn append_changesets_check_last_revealed() {
keychains_added: BTreeMap::<(), _>::new(),
last_revealed: rhs_di,
};
lhs.append(rhs);
lhs.merge(rhs);
// Existing index doesn't update if the new index in `other` is lower than `self`.
assert_eq!(lhs.last_revealed.get(&descriptor_ids[0]), Some(&7));
@ -677,7 +677,7 @@ fn applying_changesets_one_by_one_vs_aggregate_must_have_same_result() {
.iter()
.cloned()
.reduce(|mut agg, cs| {
agg.append(cs);
agg.merge(cs);
agg
})
.expect("must aggregate changesets");

8
crates/chain/tests/test_tx_graph.rs
View File

@ -7,7 +7,7 @@ use bdk_chain::{
collections::*,
local_chain::LocalChain,
tx_graph::{ChangeSet, TxGraph},
Anchor, Append, BlockId, ChainOracle, ChainPosition, ConfirmationHeightAnchor,
Anchor, BlockId, ChainOracle, ChainPosition, ConfirmationHeightAnchor, Merge,
};
use bitcoin::{
absolute, hashes::Hash, transaction, Amount, BlockHash, OutPoint, ScriptBuf, SignedAmount,
@ -1049,9 +1049,9 @@ fn test_chain_spends() {
.is_none());
}
/// Ensure that `last_seen` values only increase during [`Append::append`].
/// Ensure that `last_seen` values only increase during [`Merge::merge`].
#[test]
fn test_changeset_last_seen_append() {
fn test_changeset_last_seen_merge() {
let txid: Txid = h!("test txid");
let test_cases: &[(Option<u64>, Option<u64>)] = &[
@ -1074,7 +1074,7 @@ fn test_changeset_last_seen_append() {
};
assert!(!update.is_empty() || update_ls.is_none());
original.append(update);
original.merge(update);
assert_eq!(
&original.last_seen.get(&txid).cloned(),
Ord::max(original_ls, update_ls),

14
crates/file_store/src/store.rs
View File

@ -1,5 +1,5 @@
use crate::{bincode_options, EntryIter, FileError, IterError};
use bdk_chain::Append;
use bdk_chain::Merge;
use bincode::Options;
use std::{
fmt::{self, Debug},
@ -22,7 +22,7 @@ where
impl<C> Store<C>
where
C: Append
C: Merge
+ serde::Serialize
+ serde::de::DeserializeOwned
+ core::marker::Send
@ -147,7 +147,7 @@ where
}
};
match &mut changeset {
Some(changeset) => changeset.append(next_changeset),
Some(changeset) => changeset.merge(next_changeset),
changeset => *changeset = Some(next_changeset),
}
}
@ -365,7 +365,7 @@ mod test {
assert_eq!(
err.changeset,
changesets.iter().cloned().reduce(|mut acc, cs| {
Append::append(&mut acc, cs);
Merge::merge(&mut acc, cs);
acc
}),
"should recover all changesets that are written in full",
@ -386,7 +386,7 @@ mod test {
.cloned()
.chain(core::iter::once(last_changeset.clone()))
.reduce(|mut acc, cs| {
Append::append(&mut acc, cs);
Merge::merge(&mut acc, cs);
acc
}),
"should recover all changesets",
@ -422,13 +422,13 @@ mod test {
.take(read_count)
.map(|r| r.expect("must read valid changeset"))
.fold(TestChangeSet::default(), |mut acc, v| {
Append::append(&mut acc, v);
Merge::merge(&mut acc, v);
acc
});
// We write after a short read.
db.append_changeset(&last_changeset)
.expect("last write must succeed");
Append::append(&mut exp_aggregation, last_changeset.clone());
Merge::merge(&mut exp_aggregation, last_changeset.clone());
drop(db);
// We open the file again and check whether aggregate changeset is expected.

8
crates/sqlite/src/store.rs
View File

@ -14,8 +14,8 @@ use std::sync::{Arc, Mutex};
use crate::Error;
use bdk_chain::CombinedChangeSet;
use bdk_chain::{
indexed_tx_graph, indexer::keychain_txout, local_chain, tx_graph, Anchor, Append,
DescriptorExt, DescriptorId,
indexed_tx_graph, indexer::keychain_txout, local_chain, tx_graph, Anchor, DescriptorExt,
DescriptorId, Merge,
};
/// Persists data in to a relational schema based [SQLite] database file.
@ -538,7 +538,7 @@ where
#[cfg(test)]
mod test {
use super::*;
use crate::store::Append;
use crate::store::Merge;
use bdk_chain::bitcoin::consensus::encode::deserialize;
use bdk_chain::bitcoin::constants::genesis_block;
use bdk_chain::bitcoin::hashes::hex::FromHex;
@ -750,7 +750,7 @@ mod test {
changesets
.iter()
.fold(CombinedChangeSet::<Keychain, A>::default(), |mut i, cs| {
i.append(cs.clone());
i.merge(cs.clone());
i
});

34
crates/wallet/src/wallet/mod.rs
View File

@ -28,8 +28,8 @@ use bdk_chain::{
},
spk_client::{FullScanRequest, FullScanResult, SyncRequest, SyncResult},
tx_graph::{CanonicalTx, TxGraph, TxNode},
Append, BlockId, ChainPosition, ConfirmationTime, ConfirmationTimeHeightAnchor, FullTxOut,
Indexed, IndexedTxGraph,
BlockId, ChainPosition, ConfirmationTime, ConfirmationTimeHeightAnchor, FullTxOut, Indexed,
IndexedTxGraph, Merge,
};
use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
use bitcoin::{
@ -666,7 +666,7 @@ impl Wallet {
.reveal_next_spk(&keychain)
.expect("keychain must exist");
stage.append(indexed_tx_graph::ChangeSet::from(index_changeset).into());
stage.merge(indexed_tx_graph::ChangeSet::from(index_changeset).into());
AddressInfo {
index,
@ -696,7 +696,7 @@ impl Wallet {
.reveal_to_target(&keychain, index)
.expect("keychain must exist");
self.stage.append(index_changeset.into());
self.stage.merge(index_changeset.into());
spks.into_iter().map(move |(index, spk)| AddressInfo {
index,
@ -721,7 +721,7 @@ impl Wallet {
.expect("keychain must exist");
self.stage
.append(indexed_tx_graph::ChangeSet::from(index_changeset).into());
.merge(indexed_tx_graph::ChangeSet::from(index_changeset).into());
AddressInfo {
index,
@ -880,7 +880,7 @@ impl Wallet {
/// [`list_output`]: Self::list_output
pub fn insert_txout(&mut self, outpoint: OutPoint, txout: TxOut) {
let additions = self.indexed_graph.insert_txout(outpoint, txout);
self.stage.append(additions.into());
self.stage.merge(additions.into());
}
/// Calculates the fee of a given transaction. Returns [`Amount::ZERO`] if `tx` is a coinbase transaction.
@ -1049,7 +1049,7 @@ impl Wallet {
) -> Result<bool, local_chain::AlterCheckPointError> {
let changeset = self.chain.insert_block(block_id)?;
let changed = !changeset.is_empty();
self.stage.append(changeset.into());
self.stage.merge(changeset.into());
Ok(changed)
}
@ -1067,9 +1067,9 @@ impl Wallet {
/// must be broadcast to the network and the wallet synced via a chain source.
pub fn insert_tx(&mut self, tx: Transaction) -> bool {
let mut changeset = ChangeSet::default();
changeset.append(self.indexed_graph.insert_tx(tx).into());
changeset.merge(self.indexed_graph.insert_tx(tx).into());
let ret = !changeset.is_empty();
self.stage.append(changeset);
self.stage.merge(changeset);
ret
}
@ -1394,7 +1394,7 @@ impl Wallet {
.next_unused_spk(&change_keychain)
.expect("keychain must exist");
self.indexed_graph.index.mark_used(change_keychain, index);
self.stage.append(index_changeset.into());
self.stage.merge(index_changeset.into());
spk
}
};
@ -2230,9 +2230,9 @@ impl Wallet {
.indexed_graph
.index
.reveal_to_target_multi(&update.last_active_indices);
changeset.append(index_changeset.into());
changeset.append(self.indexed_graph.apply_update(update.graph).into());
self.stage.append(changeset);
changeset.merge(index_changeset.into());
changeset.merge(self.indexed_graph.apply_update(update.graph).into());
self.stage.merge(changeset);
Ok(())
}
@ -2317,17 +2317,17 @@ impl Wallet {
connected_to: BlockId,
) -> Result<(), ApplyHeaderError> {
let mut changeset = ChangeSet::default();
changeset.append(
changeset.merge(
self.chain
.apply_header_connected_to(&block.header, height, connected_to)?
.into(),
);
changeset.append(
changeset.merge(
self.indexed_graph
.apply_block_relevant(block, height)
.into(),
);
self.stage.append(changeset);
self.stage.merge(changeset);
Ok(())
}
@ -2350,7 +2350,7 @@ impl Wallet {
let indexed_graph_changeset = self
.indexed_graph
.batch_insert_relevant_unconfirmed(unconfirmed_txs);
self.stage.append(indexed_graph_changeset.into());
self.stage.merge(indexed_graph_changeset.into());
}
}

8
example-crates/example_bitcoind_rpc_polling/src/main.rs
View File

@ -16,7 +16,7 @@ use bdk_chain::{
indexed_tx_graph,
indexer::keychain_txout,
local_chain::{self, LocalChain},
Append, ConfirmationTimeHeightAnchor, IndexedTxGraph,
ConfirmationTimeHeightAnchor, IndexedTxGraph, Merge,
};
use example_cli::{
anyhow,
@ -191,7 +191,7 @@ fn main() -> anyhow::Result<()> {
.apply_update(emission.checkpoint)
.expect("must always apply as we receive blocks in order from emitter");
let graph_changeset = graph.apply_block_relevant(&emission.block, height);
db_stage.append((chain_changeset, graph_changeset));
db_stage.merge((chain_changeset, graph_changeset));
// commit staged db changes in intervals
if last_db_commit.elapsed() >= DB_COMMIT_DELAY {
@ -235,7 +235,7 @@ fn main() -> anyhow::Result<()> {
);
{
let db = &mut *db.lock().unwrap();
db_stage.append((local_chain::ChangeSet::default(), graph_changeset));
db_stage.merge((local_chain::ChangeSet::default(), graph_changeset));
if let Some(changeset) = db_stage.take() {
db.append_changeset(&changeset)?;
}
@ -321,7 +321,7 @@ fn main() -> anyhow::Result<()> {
continue;
}
};
db_stage.append(changeset);
db_stage.merge(changeset);
if last_db_commit.elapsed() >= DB_COMMIT_DELAY {
let db = &mut *db.lock().unwrap();

10
example-crates/example_cli/src/lib.rs
View File

@ -20,7 +20,7 @@ use bdk_chain::{
descriptor::{DescriptorSecretKey, KeyMap},
Descriptor, DescriptorPublicKey,
},
Anchor, Append, ChainOracle, DescriptorExt, FullTxOut,
Anchor, ChainOracle, DescriptorExt, FullTxOut, Merge,
};
pub use bdk_file_store;
pub use clap;
@ -263,7 +263,7 @@ where
.index
.next_unused_spk(&internal_keychain)
.expect("Must exist");
changeset.append(change_changeset);
changeset.merge(change_changeset);
let change_plan = bdk_tmp_plan::plan_satisfaction(
&graph
@ -456,7 +456,7 @@ pub fn handle_commands<CS: clap::Subcommand, S: clap::Args, A: Anchor, O: ChainO
where
O::Error: std::error::Error + Send + Sync + 'static,
C: Default
+ Append
+ Merge
+ DeserializeOwned
+ Serialize
+ From<KeychainChangeSet<A>>
@ -675,7 +675,7 @@ where
/// The initial state returned by [`init`].
pub struct Init<CS: clap::Subcommand, S: clap::Args, C>
where
C: Default + Append + Serialize + DeserializeOwned + Debug + Send + Sync + 'static,
C: Default + Merge + Serialize + DeserializeOwned + Debug + Send + Sync + 'static,
{
/// Arguments parsed by the cli.
pub args: Args<CS, S>,
@ -697,7 +697,7 @@ pub fn init<CS: clap::Subcommand, S: clap::Args, C>(
) -> anyhow::Result<Init<CS, S, C>>
where
C: Default
+ Append
+ Merge
+ Serialize
+ DeserializeOwned
+ Debug

6
example-crates/example_electrum/src/main.rs
View File

@ -10,7 +10,7 @@ use bdk_chain::{
indexer::keychain_txout,
local_chain::{self, LocalChain},
spk_client::{FullScanRequest, SyncRequest},
Append, ConfirmationHeightAnchor,
ConfirmationHeightAnchor, Merge,
};
use bdk_electrum::{
electrum_client::{self, Client, ElectrumApi},
@ -343,9 +343,9 @@ fn main() -> anyhow::Result<()> {
indexed_tx_graph::ChangeSet::<ConfirmationHeightAnchor, _>::default();
if let Some(keychain_update) = keychain_update {
let keychain_changeset = graph.index.reveal_to_target_multi(&keychain_update);
indexed_tx_graph_changeset.append(keychain_changeset.into());
indexed_tx_graph_changeset.merge(keychain_changeset.into());
}
indexed_tx_graph_changeset.append(graph.apply_update(graph_update));
indexed_tx_graph_changeset.merge(graph.apply_update(graph_update));
(chain_changeset, indexed_tx_graph_changeset)
};

4
example-crates/example_esplora/src/main.rs
View File

@ -10,7 +10,7 @@ use bdk_chain::{
indexer::keychain_txout,
local_chain::{self, LocalChain},
spk_client::{FullScanRequest, SyncRequest},
Append, ConfirmationTimeHeightAnchor,
ConfirmationTimeHeightAnchor, Merge,
};
use bdk_esplora::{esplora_client, EsploraExt};
@ -208,7 +208,7 @@ fn main() -> anyhow::Result<()> {
.index
.reveal_to_target_multi(&update.last_active_indices);
let mut indexed_tx_graph_changeset = graph.apply_update(update.graph_update);
indexed_tx_graph_changeset.append(index_changeset.into());
indexed_tx_graph_changeset.merge(index_changeset.into());
indexed_tx_graph_changeset
})
}