redgold-schema 0.1.21

A relative proof conflict resolution & irreversibility service with trust modeling custodial pooling and executor contracts
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

use crate::{error_info, HashClear, RgResult, SafeOption};
use crate::structs::{ErrorInfo, Hash, NetworkEnvironment, NodeMetadata, PartitionInfo, PeerNodeInfo, PublicKey, TransportInfo};
use crate::util::xor_distance::xorfc_hash;

impl HashClear for NodeMetadata {
    fn hash_clear(&mut self) {}
}

impl NodeMetadata {
    pub fn port_or(&self, network: NetworkEnvironment) -> u16 {
        self.transport_info.as_ref()
            .and_then(|ti| ti.port_offset)
            .unwrap_or(network.default_port_offset() as i64) as u16
    }
    pub fn public_key_bytes(&self) -> Result<Vec<u8>, ErrorInfo> {
        let x = self.public_key.safe_get()?;
        let y= x.bytes.safe_get()?.value.clone();
        Ok(y)
    }

    pub fn long_identifier(&self) -> String {
        let pk = self.public_key.clone().and_then(|p| p.hex().ok()).unwrap_or("".to_string());
        let info = self.transport_info.clone().expect("ti");
        let ip = info.external_host.or(info.external_ipv4).expect("ip");
        format!("node_name {} public key {} ip {}",
                self.node_name.clone().unwrap_or("none".to_string()), pk, ip,
        )
    }

    pub fn external_address(&self) -> RgResult<String> {
        self.transport_info.safe_get_msg("Missing transport info")
            .and_then(|t| t.external_address())
    }

    pub fn tx_in_range(&self, h: &Hash) -> bool {
        self.hash_in_range(h, |i| i.transaction_hash)
    }

    pub fn hash_in_range(&self, h: &Hash, f: fn(&PartitionInfo) -> Option<i64>) -> bool {
        if let Some(d) = self.partition_info.as_ref().and_then(f) {
            let pk = self.public_key.as_ref().expect("pk");
            xorfc_hash(h, pk) < d
        } else {
            true
        }
    }

}


impl PeerNodeInfo {
    pub fn public_keys(&self) -> Vec<PublicKey> {
        let mut res = vec![];
        if let Some(t) = &self.latest_node_transaction {
            if let Ok(p) = &t.peer_data() {
                for n in &p.node_metadata {
                    if let Some(p) = &n.public_key {
                        res.push(p.clone());
                    }
                }
            }
        }

        if let Some(t) = &self.latest_node_transaction {
            if let Ok(n) = &t.node_metadata() {
                if let Some(p) = &n.public_key {
                    res.push(p.clone());
                }
            }
        }

        res
    }
}

impl TransportInfo {
    fn external_address(&self) -> RgResult<String> {
        self.external_host.as_ref().or(self.external_ipv4.as_ref()).safe_get_msg("No external address")
            .cloned()
            .cloned()
    }
}