waterfalls 0.9.2

Waterfalls provide blockchain data to liquid and bitcoin light-client wallets
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::{Height, ScriptHash, Timestamp, TxSeen};
use anyhow::Result;
use elements::{BlockHash, OutPoint};
use std::collections::BTreeMap;

#[cfg(feature = "db")]
pub mod db;

pub mod memory;

pub enum AnyStore {
    #[cfg(feature = "db")]
    Db(db::DBStore),
    Mem(memory::MemoryStore),
}
impl AnyStore {
    pub(crate) fn stats(&self) -> Option<String> {
        match self {
            AnyStore::Db(dbstore) => dbstore.stats(),
            AnyStore::Mem(_) => None,
        }
    }
}

pub trait Store {
    /// Hash the given script
    ///
    /// It's in the trait cause it can be salted with some random values contained in the
    /// concrete implementation to avoid attacker brute force collisions
    fn hash(&self, script: &[u8]) -> ScriptHash;

    /// Iterate over blocks metadata to preload those in memory
    fn iter_hash_ts(&self) -> Box<dyn Iterator<Item = BlockMeta> + '_>;

    /// Get given outpoints from the UTXO set to compute the mempool history
    fn get_utxos(&self, outpoints: &[OutPoint]) -> Result<Vec<Option<ScriptHash>>>;

    /// Get history of multiple (usually 20 like the gap limit) scripts hash at once
    fn get_history(&self, scripts: &[ScriptHash]) -> Result<Vec<Vec<TxSeen>>>;

    /// update the store with all the data from the last block
    fn update(
        &self,
        block_meta: &BlockMeta,
        utxo_spent: Vec<(u32, OutPoint, crate::be::Txid)>,
        history_map: BTreeMap<ScriptHash, Vec<TxSeen>>, // We want this sorted because when inserted in the write batch it's faster (see benches and test guaranteeing encoding order match struct ordering)
        utxo_created: BTreeMap<OutPoint, ScriptHash>, // We want this sorted because when inserted in the write batch it's faster (see benches and test guaranteeing encoding order match struct ordering)
    ) -> Result<()>;

    /// Reorg, reinsert the last block unspent utxos
    fn reorg(&self);

    /// Called when the initial block download is finished
    fn ibd_finished(&self);
}

impl Store for AnyStore {
    fn hash(&self, script: &[u8]) -> ScriptHash {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.hash(script),
            AnyStore::Mem(m) => m.hash(script),
        }
    }

    fn iter_hash_ts(&self) -> Box<dyn Iterator<Item = BlockMeta> + '_> {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.iter_hash_ts(),
            AnyStore::Mem(m) => m.iter_hash_ts(),
        }
    }

    fn get_utxos(&self, outpoints: &[OutPoint]) -> Result<Vec<Option<ScriptHash>>> {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.get_utxos(outpoints),
            AnyStore::Mem(m) => m.get_utxos(outpoints),
        }
    }

    fn get_history(&self, scripts: &[ScriptHash]) -> Result<Vec<Vec<TxSeen>>> {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.get_history(scripts),
            AnyStore::Mem(m) => m.get_history(scripts),
        }
    }

    fn update(
        &self,
        block_meta: &BlockMeta,
        utxo_spent: Vec<(u32, OutPoint, crate::be::Txid)>,
        history_map: BTreeMap<ScriptHash, Vec<TxSeen>>,
        utxo_created: BTreeMap<OutPoint, ScriptHash>,
    ) -> Result<()> {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.update(block_meta, utxo_spent, history_map, utxo_created),
            AnyStore::Mem(m) => m.update(block_meta, utxo_spent, history_map, utxo_created),
        }
    }

    fn reorg(&self) {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.reorg(),
            AnyStore::Mem(m) => m.reorg(),
        }
    }

    fn ibd_finished(&self) {
        match self {
            #[cfg(feature = "db")]
            AnyStore::Db(d) => d.ibd_finished(),
            AnyStore::Mem(m) => m.ibd_finished(),
        }
    }
}

#[derive(Clone, Debug)]
pub struct BlockMeta {
    pub height: Height,
    pub hash: BlockHash,
    pub timestamp: Timestamp,
}

impl BlockMeta {
    pub fn new(height: Height, hash: BlockHash, timestamp: Timestamp) -> BlockMeta {
        BlockMeta {
            height,
            hash,
            timestamp,
        }
    }

    pub(crate) fn height(&self) -> Height {
        self.height
    }

    pub(crate) fn timestamp(&self) -> Timestamp {
        self.timestamp
    }

    pub(crate) fn hash(&self) -> BlockHash {
        self.hash
    }
}