iop-hydra-sdk 0.0.16

Hydraledger specific modules for the IOP Stack™ SDK
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

use super::*;

use iop_vault::{Vault, VaultPlugin};

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Plugin {
    public_state: Arc<RwLock<PublicState>>,
    parameters: Parameters,
}

#[cfg_attr(target_arch = "wasm32", typetag::serialize(name = "Hydra"))]
#[cfg_attr(not(target_arch = "wasm32"), typetag::serde(name = "Hydra"))]
impl VaultPlugin for Plugin {
    fn name(&self) -> &'static str {
        "Hydra"
    }

    fn to_any(&self) -> Box<dyn Any> {
        Box::new(self.clone())
    }

    fn eq(&self, other: &dyn VaultPlugin) -> bool {
        let other: Result<Box<Plugin>, _> = other.to_any().downcast();
        match other {
            Ok(p) => self.parameters == p.parameters,
            Err(_) => false,
        }
    }
}

impl Plugin {
    pub fn new(parameters: Parameters, xpub: String, receive_keys: u32, change_keys: u32) -> Self {
        let public_state = PublicState { xpub, receive_keys, change_keys };
        let public_state = Arc::new(RwLock::new(public_state));
        Self { public_state, parameters }
    }

    fn instantiate(
        vault: &mut Vault, unlock_password: impl AsRef<str>, parameters: &Parameters,
        receive_keys: u32, change_keys: u32,
    ) -> Result<()> {
        let seed = vault.unlock(unlock_password.as_ref())?;
        let account = Self::create_account(parameters, &seed)?;
        let pub_account = account.neuter();
        let plugin =
            Self::new(parameters.to_owned(), pub_account.to_xpub(), receive_keys, change_keys);
        vault.add(Box::new(plugin))
    }

    pub fn create(
        vault: &mut Vault, unlock_password: impl AsRef<str>, parameters: &Parameters,
    ) -> Result<()> {
        Self::instantiate(vault, unlock_password, parameters, 0, 0)
    }

    pub fn init(
        vault: &mut Vault, unlock_password: impl AsRef<str>, parameters: &Parameters,
    ) -> Result<()> {
        Self::instantiate(vault, unlock_password, parameters, 1, 0)
    }

    pub fn get(
        vault: &Vault, parameters: &Parameters,
    ) -> Result<BoundPlugin<Plugin, Public, Private>> {
        let _network = Networks::by_name(&parameters.network)?; // checks if network name is supported
        ensure!(parameters.account >= 0, "Hydra account number cannot be negative");

        let hydra_plugins = vault.plugins_by_type::<Plugin>()?;
        let plugin: &Plugin =
            hydra_plugins
                .iter()
                .by_ref()
                .find(|p| p.parameters == *parameters)
                .with_context(|| "Could not find Hydra plugin with given parameters")?;
        Ok(BoundPlugin::new(vault.to_owned(), plugin.to_owned()))
    }

    pub fn network(&self) -> &'static dyn Network<Suite = Secp256k1> {
        Networks::by_name(&self.parameters.network).unwrap()
    }

    pub fn account(&self) -> i32 {
        self.parameters.account
    }

    pub fn create_account(parameters: &Parameters, seed: &Seed) -> Result<Bip44Account<Secp256k1>> {
        let network = Networks::by_name(&parameters.network)?;
        Bip44.network(seed, network)?.account(parameters.account)
    }

    pub(super) fn to_state(&self) -> Box<dyn State<PublicState>> {
        Box::new(self.public_state.to_owned())
    }
}