iuna

iuna - experimental devnet protocol
git clone https://iuna.jhx.app/git/iuna.git
Log | Files | Refs | README | LICENSE

ledger_view.rs (2876B)

      1 use anyhow::Result;
      2 
      3 use std::collections::BTreeSet;
      4 
      5 use crate::domain::{
      6     BlindedReveal, BlindedTransaction, Block, BurnLeaderRank, Ledger, OutPoint, Transaction,
      7 };
      8 
      9 use super::{NodeCore, helpers::transaction_input_outpoints};
     10 
     11 impl NodeCore {
     12     pub fn ledger(&self) -> &Ledger {
     13         &self.ledger
     14     }
     15 
     16     pub(crate) fn clone_ledger(&self) -> Ledger {
     17         self.ledger.clone()
     18     }
     19 
     20     pub fn wallet_view_ledger(&self) -> Result<Ledger> {
     21         let mut ledger = self.ledger.clone();
     22         self.queue_local_block_anchor(&mut ledger)?;
     23         self.queue_owned_blinded_payloads(&mut ledger)?;
     24         Ok(ledger)
     25     }
     26 
     27     pub fn wallet_pending_spent_outpoints(&self) -> BTreeSet<OutPoint> {
     28         let mut spent = self
     29             .ledger
     30             .pending()
     31             .iter()
     32             .flat_map(transaction_input_outpoints)
     33             .chain(
     34                 self.ledger
     35                     .pending_blinded_transactions()
     36                     .iter()
     37                     .flat_map(|transaction| {
     38                         transaction
     39                             .inputs
     40                             .iter()
     41                             .map(|input| input.outpoint.clone())
     42                     }),
     43             )
     44             .collect::<BTreeSet<_>>();
     45         if let Some((height, burn)) = &self.local_block_anchor_burn {
     46             if *height == self.ledger.height() && !self.ledger.has_transaction(burn.signature()) {
     47                 spent.extend(transaction_input_outpoints(burn));
     48             }
     49         }
     50         spent
     51     }
     52 
     53     pub fn chain(&self) -> &[Block] {
     54         self.ledger.chain()
     55     }
     56 
     57     pub fn chain_height(&self) -> u64 {
     58         self.ledger.height()
     59     }
     60 
     61     pub fn chain_tip_hash(&self) -> String {
     62         self.ledger.tip_hash().to_string()
     63     }
     64 
     65     pub fn has_real_chain(&self) -> bool {
     66         !self.ledger.is_setup_placeholder()
     67     }
     68 
     69     pub fn recent_blocks(&self, limit: usize) -> Vec<Block> {
     70         self.ledger.recent_blocks(limit)
     71     }
     72 
     73     pub fn blocks_before(&self, before_height: u64, limit: usize) -> Vec<Block> {
     74         self.ledger.blocks_before(before_height, limit)
     75     }
     76 
     77     pub fn burn_leader_ranks_for_block(&self, height: u64) -> Result<Vec<BurnLeaderRank>> {
     78         self.ledger.burn_leader_ranks_for_block(height)
     79     }
     80 
     81     pub fn pending_transactions(&self) -> Vec<Transaction> {
     82         self.ledger.pending().to_vec()
     83     }
     84 
     85     pub fn pending_blinded_transactions(&self) -> Vec<BlindedTransaction> {
     86         self.ledger.pending_blinded_transactions().to_vec()
     87     }
     88 
     89     pub fn pending_blinded_reveals(&self) -> Vec<BlindedReveal> {
     90         self.ledger.pending_blinded_reveals().to_vec()
     91     }
     92 
     93     pub fn pending_revealed_blinded_transactions(
     94         &self,
     95     ) -> Vec<crate::domain::RevealedBlindedTransaction> {
     96         self.ledger.pending_revealed_blinded_transactions()
     97     }
     98 }