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
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

use itertools::{Either, Itertools};
use serde::{Deserialize, Serialize};
use crate::servers::Server;
use crate::structs::{Address, PeerId, PublicKey, TrustRatingLabel};

#[derive(Serialize, Deserialize, Clone)]
pub struct NamedXpub {
    pub name: String,
    pub derivation_path: String,
    pub xpub: String,
    pub hot_offset: Option<String>
}

#[derive(Serialize, Deserialize, Clone)]
pub struct SavedAddress {
    name: String,
    address: Address,
    contact_name: String
}

#[derive(Serialize, Deserialize, Clone)]
pub struct WatchedAddress {
    name: String,
    address: Address,
    alert_all: bool,
    alert_outgoing: bool
}


#[derive(Serialize, Deserialize, Clone)]
pub struct ServerTrustRatingLabels {
    pub peer_id_index: i64,
    pub labels: Vec<TrustRatingLabel>
}

#[derive(Serialize, Deserialize, Clone, PartialEq)]
pub struct Identity {
    pub name: String,
    pub peer_id_index: i64,
    pub xpub_name: String
}

#[derive(Serialize, Deserialize, Clone, PartialEq)]
pub struct Contact {
    pub name: String,
    pub peer_id: Option<PeerId>,
}

#[derive(Serialize, Deserialize, Clone, PartialEq)]
pub struct StoredMnemonic {
    pub name: String,
    pub mnemonic: String,
}

#[derive(Serialize, Deserialize, Clone, PartialEq)]
pub struct StoredPrivateKey {
    pub name: String,
    pub key_hex: String,
}


#[derive(Serialize, Deserialize, Clone)]
pub struct LocalStoredState {
    pub servers: Vec<Server>,
    pub xpubs: Vec<NamedXpub>,
    pub trust: Vec<ServerTrustRatingLabels>,
    pub saved_addresses: Option<Vec<SavedAddress>>,
    pub contacts: Vec<Contact>,
    pub watched_address: Vec<Address>,
    pub email_alert_config: Option<String>,
    pub identities: Vec<Identity>,
    pub mnemonics: Option<Vec<StoredMnemonic>>,
    pub private_keys: Option<Vec<StoredPrivateKey>>
}

impl LocalStoredState {
    pub fn key_names(&self) -> Vec<String> {
        let mut k = vec!["default".to_string()];
        for key in self.mnemonics.as_ref().unwrap_or(&vec![]) {
            k.push(key.name.clone());
        }
        for key in self.private_keys.as_ref().unwrap_or(&vec![]) {
            k.push(key.name.clone());
        }
        k
    }
    pub fn by_key(&self, name: &String) -> Option<Either<StoredMnemonic, StoredPrivateKey>> {
        if let Some(mnemonics) = &self.mnemonics {
            for mnemonic in mnemonics {
                if &mnemonic.name == name {
                    return Some(Either::Left(mnemonic.clone()));
                }
            }
        }
        if let Some(private_keys) = &self.private_keys {
            for private_key in private_keys {
                if &private_key.name == name {
                    return Some(Either::Right(private_key.clone()));
                }
            }
        }
        None
    }
}

impl Default for LocalStoredState {
    fn default() -> Self {
        Self {
            servers: vec![],
            xpubs: vec![],
            trust: vec![],
            saved_addresses: None,
            contacts: vec![],
            watched_address: vec![],
            email_alert_config: None,
            identities: vec![],
            mnemonics: None,
            private_keys: None,
        }
    }
}