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};
}
#[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,
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.
impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
where
- I::ChangeSet: Default + Append,
+ I::ChangeSet: Default + Merge,
{
fn index_tx_graph_changeset(
&mut self,
) -> 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
}
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));
}
}
}
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(
/// 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
};
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
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 }
}
}
-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 {
ops::{Bound, RangeBounds},
};
-use crate::Append;
+use crate::Merge;
/// The default lookahead for a [`KeychainTxOutIndex`]
pub const DEFAULT_LOOKAHEAD: u32 = 25;
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
}
for (keychain, &index) in keychains {
if let Some((_, new_changeset)) = self.reveal_to_target(keychain, index) {
- changeset.append(new_changeset);
+ changeset.merge(new_changeset);
}
}
match self.reveal_next_spk(keychain) {
Some(((i, spk), change)) => {
spks.push((i, spk));
- changeset.append(change);
+ changeset.merge(change);
}
None => break,
}
///
/// 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",
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)
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;
}
}
-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)
}
}
-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)
}
}
-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)
}
}
}
-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);
//! 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;
//! [`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;
) -> 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
}
.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
}
}
}
-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);
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,
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};
}
// 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()
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));
.iter()
.cloned()
.reduce(|mut agg, cs| {
- agg.append(cs);
+ agg.merge(cs);
agg
})
.expect("must aggregate changesets");
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,
.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>)] = &[
};
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),
use crate::{bincode_options, EntryIter, FileError, IterError};
-use bdk_chain::Append;
+use bdk_chain::Merge;
use bincode::Options;
use std::{
fmt::{self, Debug},
impl<C> Store<C>
where
- C: Append
+ C: Merge
+ serde::Serialize
+ serde::de::DeserializeOwned
+ core::marker::Send
}
};
match &mut changeset {
- Some(changeset) => changeset.append(next_changeset),
+ Some(changeset) => changeset.merge(next_changeset),
changeset => *changeset = Some(next_changeset),
}
}
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",
.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",
.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.
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.
#[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;
changesets
.iter()
.fold(CombinedChangeSet::<Keychain, A>::default(), |mut i, cs| {
- i.append(cs.clone());
+ i.merge(cs.clone());
i
});
},
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::{
.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,
.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,
.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,
/// [`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.
) -> 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)
}
/// 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
}
.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
}
};
.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(())
}
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(())
}
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());
}
}
indexed_tx_graph,
indexer::keychain_txout,
local_chain::{self, LocalChain},
- Append, ConfirmationTimeHeightAnchor, IndexedTxGraph,
+ ConfirmationTimeHeightAnchor, IndexedTxGraph, Merge,
};
use example_cli::{
anyhow,
.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 {
);
{
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)?;
}
continue;
}
};
- db_stage.append(changeset);
+ db_stage.merge(changeset);
if last_db_commit.elapsed() >= DB_COMMIT_DELAY {
let db = &mut *db.lock().unwrap();
descriptor::{DescriptorSecretKey, KeyMap},
Descriptor, DescriptorPublicKey,
},
- Anchor, Append, ChainOracle, DescriptorExt, FullTxOut,
+ Anchor, ChainOracle, DescriptorExt, FullTxOut, Merge,
};
pub use bdk_file_store;
pub use clap;
.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
where
O::Error: std::error::Error + Send + Sync + 'static,
C: Default
- + Append
+ + Merge
+ DeserializeOwned
+ Serialize
+ From<KeychainChangeSet<A>>
/// 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>,
) -> anyhow::Result<Init<CS, S, C>>
where
C: Default
- + Append
+ + Merge
+ Serialize
+ DeserializeOwned
+ Debug
indexer::keychain_txout,
local_chain::{self, LocalChain},
spk_client::{FullScanRequest, SyncRequest},
- Append, ConfirmationHeightAnchor,
+ ConfirmationHeightAnchor, Merge,
};
use bdk_electrum::{
electrum_client::{self, Client, ElectrumApi},
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)
};
indexer::keychain_txout,
local_chain::{self, LocalChain},
spk_client::{FullScanRequest, SyncRequest},
- Append, ConfirmationTimeHeightAnchor,
+ ConfirmationTimeHeightAnchor, Merge,
};
use bdk_esplora::{esplora_client, EsploraExt};
.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
})
}
projects / bdk / commitdiff