Struct ChainTracker

pub struct ChainTracker<L: ChainListener> {
    pub headers: VecDeque<Headers>,
    pub tip: Headers,
    pub height: u32,
    pub network: Network,
    pub listeners: OrderedMap<L::Key, (L, ListenSlot)>,
    pub trusted_oracle_pubkeys: Vec<PublicKey>,
    /* private fields */
}

Track chain, with basic validation

Fields

headers: VecDeque<Headers>

headers past the tip

tip: Headers

tip header

height: u32

height

network: Network

The network

listeners: OrderedMap<L::Key, (L, ListenSlot)>

listeners

trusted_oracle_pubkeys: Vec<PublicKey>

public keys of trusted TXO oracle

Implementations

impl<L: ChainListener> ChainTracker<L>

pub const MAX_REORG_SIZE: usize = 100usize

Maximum reorg size that we will accept

pub fn new( network: Network, height: u32, tip: Headers, node_id: PublicKey, validator_factory: Arc<dyn ValidatorFactory>, trusted_oracle_pubkeys: Vec<PublicKey>, ) -> Result<Self, Error>

Create a new tracker

pub fn set_allow_deep_reorgs(&mut self, allow: bool)

Set whether deep reorgs are allowed

pub fn restore( headers: VecDeque<Headers>, tip: Headers, height: u32, network: Network, listeners: OrderedMap<L::Key, (L, ListenSlot)>, node_id: PublicKey, validator_factory: Arc<dyn ValidatorFactory>, trusted_oracle_pubkeys: Vec<PublicKey>, ) -> Self

Restore a tracker

pub fn from_genesis( network: Network, node_id: PublicKey, validator_factory: Arc<dyn ValidatorFactory>, trusted_oracle_pubkeys: Vec<PublicKey>, ) -> Self

Create a tracker at genesis

pub fn for_network( network: Network, node_id: PublicKey, validator_factory: Arc<dyn ValidatorFactory>, trusted_oracle_pubkeys: Vec<PublicKey>, ) -> Self

Create a tracker for a network, from a checkpoint if exists or from genesis otherwise

pub fn tip(&self) -> &Headers

Current chain tip header

pub fn headers(&self) -> &VecDeque<Headers>

Headers past the tip

pub fn height(&self) -> u32

Height of current chain tip

pub fn remove_block( &mut self, proof: TxoProof, supplied_prev_headers: Headers, ) -> Result<BlockHeader, Error>

Remove block at tip due to reorg

The previous block and filter headers are provided in case the reorg is too deep for our local memory of headers. However, this should only be used on testnet, since a deep reorg may be incompatible with the Lightning security model.

pub fn restore_listener( &mut self, outpoint: L::Key, listener: L, slot: ListenSlot, )

Restore a listener

pub fn block_chunk( &mut self, hash: BlockHash, offset: u32, chunk: &[u8], ) -> Result<(), Error>

Handle a streamed block

pub fn add_block( &mut self, header: BlockHeader, proof: TxoProof, ) -> Result<(), Error>

Add a block, which becomes the new tip

pub fn add_listener( &mut self, listener: L, initial_txid_watches: OrderedSet<Txid>, )

Add a listener and initialize the watched outpoint set

pub fn remove_listener(&mut self, key: &L::Key)

Remove a listener

pub fn add_listener_watches( &mut self, key: &L::Key, watches: OrderedSet<OutPoint>, )

Add more watches to a listener

pub fn get_all_forward_watches(&self) -> (Vec<Txid>, Vec<OutPoint>)

Return all Txid and OutPoint watches for future blocks.

pub fn get_all_reverse_watches(&self) -> (Vec<Txid>, Vec<OutPoint>)

Return all Txid and OutPoint watches for removing blocks. This is a superset of the forward watches, and also includes watches for outpoints which were seen as spent in previous blocks.