urma-chain 0.3.0

URMA blockchain observations, transaction decoding and proof-of-work validation
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

use crate::config;
use bitcoin::{BlockHash, Txid};
use serde::{Deserialize, Serialize};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PowFunction {
    Sha256d,
    Scrypt,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ChainParams {
    pub magic: [u8; 4],
    pub port: u16,
    pub dns_seeds: &'static [&'static str],
    pub fixed_seeds: &'static [&'static str],
    pub pow: PowFunction,
    pub pow_limit_bits: u32,
    pub retarget_interval: u64,
    pub retarget_lookback: u64,
    pub target_timespan: u32,
    pub target_spacing: u32,
    pub allow_min_difficulty: bool,
    pub retargets: bool,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Chain {
    BitcoinMainnet,
    BitcoinRegtest,
    BitcoinTestnet4,
    LitecoinMainnet,
    LitecoinTestnet,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct ChainId(pub BlockHash);

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct BlockRef {
    pub height: u64,
    pub hash: BlockHash,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Placement {
    Unknown,
    Mempool,
    Included(BlockRef),
    Orphaned(BlockRef),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum InclusionTrust {
    ProviderClaim,
    ValidatingNode,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Observation {
    pub chain: ChainId,
    pub txid: Txid,
    pub tip: BlockRef,
    pub placement: Placement,
    pub trust: InclusionTrust,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ChainUpdate {
    Advanced {
        previous: BlockRef,
        tip: BlockRef,
    },
    Reorganized {
        previous: BlockRef,
        ancestor: BlockRef,
        tip: BlockRef,
    },
}

impl Chain {
    pub const LITECOIN_TESTNET_GENESIS: &str =
        "4966625a4b2851d9fdee139e56211a0d88575f59ed816ff5e6a63deb4e3e29a0";

    pub fn label(self) -> &'static str {
        match self {
            Self::LitecoinMainnet => "Litecoin mainnet",
            Self::LitecoinTestnet => "Litecoin testnet",
            Self::BitcoinMainnet => "Bitcoin mainnet",
            Self::BitcoinRegtest => "Bitcoin regtest",
            Self::BitcoinTestnet4 => "Bitcoin testnet4",
        }
    }

    /// Bech32 human-readable part of this chain's segwit addresses.
    pub fn address_hrp(self) -> &'static str {
        match self {
            Self::BitcoinMainnet => "bc",
            Self::BitcoinRegtest => "bcrt",
            Self::BitcoinTestnet4 => "tb",
            Self::LitecoinMainnet => "ltc",
            Self::LitecoinTestnet => "tltc",
        }
    }

    pub fn params(self) -> &'static ChainParams {
        match self {
            Self::BitcoinMainnet => &config::BITCOIN_MAINNET,
            Self::LitecoinMainnet => &config::LITECOIN_MAINNET,
            Self::LitecoinTestnet => &config::LITECOIN_TESTNET,
            Self::BitcoinRegtest => &config::BITCOIN_REGTEST,
            Self::BitcoinTestnet4 => &config::BITCOIN_TESTNET4,
        }
    }

    pub fn genesis(self) -> Result<ChainId, bitcoin::hex::HexToArrayError> {
        let genesis = match self {
            Self::BitcoinMainnet => {
                bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Bitcoin).block_hash()
            }
            Self::BitcoinRegtest => {
                bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Regtest).block_hash()
            }
            Self::BitcoinTestnet4 => {
                bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Testnet4)
                    .block_hash()
            }
            Self::LitecoinMainnet => {
                "12a765e31ffd4059bada1e25190f6e98c99d9714d334efa41a195a7e7e04bfe2".parse()?
            }
            Self::LitecoinTestnet => Self::LITECOIN_TESTNET_GENESIS.parse()?,
        };
        Ok(ChainId(genesis))
    }
}