hop-sdk 0.1.0

Client SDK for the Polkadot HOP protocol
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

use sp_core::Pair;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SignatureScheme {
    Ed25519,
    Sr25519,
    Ecdsa,
    Eth,
}

pub struct Keypair {
    pub scheme: SignatureScheme,
    pub public_key: Vec<u8>,
    pub secret_key: Vec<u8>,
    pub ticket_secret: Vec<u8>,
}

pub fn hash(data: &[u8]) -> [u8; 32] {
    sp_core::hashing::blake2_256(data)
}

pub fn generate_keypair(scheme: SignatureScheme) -> Keypair {
    match scheme {
        SignatureScheme::Ed25519 => {
            let (pair, seed) = sp_core::ed25519::Pair::generate();
            Keypair {
                scheme,
                public_key: pair.public().0.to_vec(),
                secret_key: seed.to_vec(),
                ticket_secret: seed.to_vec(),
            }
        }
        SignatureScheme::Sr25519 => {
            let (pair, seed) = sp_core::sr25519::Pair::generate();
            Keypair {
                scheme,
                public_key: pair.public().0.to_vec(),
                secret_key: seed.to_vec(),
                ticket_secret: seed.to_vec(),
            }
        }
        SignatureScheme::Ecdsa | SignatureScheme::Eth => {
            let (pair, seed) = sp_core::ecdsa::Pair::generate();
            Keypair {
                scheme,
                public_key: pair.public().0.to_vec(),
                secret_key: seed.to_vec(),
                ticket_secret: seed.to_vec(),
            }
        }
    }
}

pub fn sign(message: &[u8], secret_key: &[u8], scheme: SignatureScheme) -> Vec<u8> {
    match scheme {
        SignatureScheme::Ed25519 => {
            let pair =
                sp_core::ed25519::Pair::from_seed_slice(secret_key).expect("valid ed25519 seed");
            pair.sign(message).0.to_vec()
        }
        SignatureScheme::Sr25519 => {
            let pair =
                sp_core::sr25519::Pair::from_seed_slice(secret_key).expect("valid sr25519 seed");
            pair.sign(message).0.to_vec()
        }
        SignatureScheme::Ecdsa | SignatureScheme::Eth => {
            let pair =
                sp_core::ecdsa::Pair::from_seed_slice(secret_key).expect("valid ecdsa seed");
            let msg: &[u8; 32] = message.try_into().expect("ecdsa message must be 32 bytes");
            pair.sign_prehashed(msg).0.to_vec()
        }
    }
}

pub fn signing_key_from_ticket_secret(
    ticket_secret: &[u8],
    _scheme: SignatureScheme,
) -> Vec<u8> {
    ticket_secret.to_vec()
}