aleph_client 3.0.0

This crate provides a Rust application interface for submitting transactions to `aleph-node` chain.
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

pub use crate::aleph_zero::api::runtime_types::*;
use crate::{
    aleph_runtime::SessionKeys,
    api::runtime_types::{
        primitives::app::Public as AlephPublic,
        sp_consensus_aura::sr25519::app_sr25519::Public as AuraPublic,
        sp_core::{ed25519::Public as EdPublic, sr25519::Public as SrPublic},
    },
    pallet_staking::EraRewardPoints,
    sp_weights::weight_v2::Weight,
};

impl<AccountId> Default for EraRewardPoints<AccountId> {
    fn default() -> Self {
        Self {
            total: 0,
            individual: vec![],
        }
    }
}

// Manually implementing decoding
impl From<Vec<u8>> for SessionKeys {
    fn from(bytes: Vec<u8>) -> Self {
        assert_eq!(bytes.len(), 64);
        Self {
            aura: AuraPublic(SrPublic(
                bytes[..32]
                    .try_into()
                    .expect("Failed to convert bytes slice to an Aura key!"),
            )),
            aleph: AlephPublic(EdPublic(
                bytes[32..64]
                    .try_into()
                    .expect("Failed to convert bytes slice to an Aleph key!"),
            )),
        }
    }
}

impl TryFrom<String> for SessionKeys {
    type Error = ();

    fn try_from(keys: String) -> Result<Self, Self::Error> {
        let bytes: Vec<u8> = match hex::FromHex::from_hex(keys) {
            Ok(bytes) => bytes,
            Err(_) => return Err(()),
        };
        Ok(SessionKeys::from(bytes))
    }
}

impl Weight {
    /// Returns new instance of weight v2 object.
    pub const fn new(ref_time: u64, proof_size: u64) -> Self {
        Self {
            ref_time,
            proof_size,
        }
    }
}