ddk 1.0.11

application tooling for DLCs 🌊
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use super::WalletStorage;
use crate::error::WalletError;
use crate::logger::{log_debug, WriteLog};
use crate::{chain::EsploraClient, logger::Logger};
use bdk_chain::spk_client::FullScanRequest;
use bdk_esplora::EsploraAsyncExt;
use bdk_wallet::{KeychainKind, PersistedWallet, Update};
use std::collections::BTreeMap;
use std::sync::Arc;

type Result<T> = std::result::Result<T, WalletError>;

#[tracing::instrument(skip_all)]
pub async fn sync(
    wallet: &mut PersistedWallet<WalletStorage>,
    blockchain: &EsploraClient,
    storage: &mut WalletStorage,
    logger: Arc<Logger>,
) -> Result<()> {
    let block_height = blockchain
        .async_client
        .get_height()
        .await
        .map_err(|e| WalletError::Esplora(e.to_string()))?;
    let prev_tip = wallet.latest_checkpoint();

    if prev_tip.height() == block_height {
        return Ok(());
    }

    log_debug!(
        logger,
        "Syncing wallet with latest known height. height={} wallet_height={}",
        block_height,
        prev_tip.height()
    );
    let sync_result = if prev_tip.height() == 0 {
        log_debug!(logger, "Performing a full chain scan.");
        let spks = wallet
            .all_unbounded_spk_iters()
            .get(&KeychainKind::External)
            .unwrap()
            .to_owned();
        let chain = FullScanRequest::builder()
            .spks_for_keychain(KeychainKind::External, spks.clone())
            .chain_tip(prev_tip)
            .build();
        let sync = blockchain
            .async_client
            .full_scan(chain, 10, 1)
            .await
            .map_err(|e| WalletError::Esplora(e.to_string()))?;
        Update {
            last_active_indices: sync.last_active_indices,
            tx_update: sync.tx_update,
            chain: sync.chain_update,
        }
    } else {
        let spks = wallet
            .start_sync_with_revealed_spks()
            .chain_tip(prev_tip)
            .build();
        let sync = blockchain
            .async_client
            .sync(spks, 1)
            .await
            .map_err(|e| WalletError::Esplora(e.to_string()))?;
        let indices = wallet.derivation_index(KeychainKind::External).unwrap_or(0);
        let internal_index = wallet.derivation_index(KeychainKind::Internal).unwrap_or(0);
        let mut last_active_indices = BTreeMap::new();
        last_active_indices.insert(KeychainKind::External, indices);
        last_active_indices.insert(KeychainKind::Internal, internal_index);
        Update {
            last_active_indices,
            tx_update: sync.tx_update,
            chain: sync.chain_update,
        }
    };
    wallet.apply_update(sync_result)?;
    wallet
        .persist_async(storage)
        .await
        .map_err(|e| WalletError::WalletPersistanceError(e.to_string()))?;
    Ok(())
}