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

// Copyright 2021 Parity Technologies (UK) Ltd.
// This file is part of Parity Bridges Common.

// Parity Bridges Common is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Parity Bridges Common is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.

//! Utilities for working with test accounts.

use codec::Encode;
use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature};
use finality_grandpa::voter_set::VoterSet;
use sp_consensus_grandpa::{AuthorityId, AuthorityList, AuthorityWeight};
use sp_core::crypto::UncheckedFrom;
use sp_runtime::RuntimeDebug;
use sp_std::{prelude::*, vec};

/// Set of test accounts with friendly names.
pub const ALICE: Account = Account(0);
pub const BOB: Account = Account(1);
pub const CHARLIE: Account = Account(2);
pub const DAVE: Account = Account(3);
pub const EVE: Account = Account(4);
pub const FERDIE: Account = Account(5);

/// A test account which can be used to sign messages.
#[derive(RuntimeDebug, Clone, Copy)]
pub struct Account(pub u16);

impl Account {
    pub fn public(&self) -> PublicKey {
        (&self.secret()).into()
    }

    pub fn secret(&self) -> SecretKey {
        let data = self.0.encode();
        let mut bytes = [0_u8; 32];
        bytes[0..data.len()].copy_from_slice(&data);
        SecretKey::from_bytes(&bytes)
            .expect("A static array of the correct length is a known good.")
    }

    pub fn pair(&self) -> Keypair {
        let mut pair: [u8; 64] = [0; 64];

        let secret = self.secret();
        pair[..32].copy_from_slice(&secret.to_bytes());

        let public = self.public();
        pair[32..].copy_from_slice(&public.to_bytes());

        Keypair::from_bytes(&pair)
            .expect("We expect the SecretKey to be good, so this must also be good.")
    }

    pub fn sign(&self, msg: &[u8]) -> Signature {
        use ed25519_dalek::Signer;
        self.pair().sign(msg)
    }
}

impl From<Account> for AuthorityId {
    fn from(p: Account) -> Self {
        UncheckedFrom::unchecked_from(p.public().to_bytes())
    }
}

/// Get a valid set of voters for a Grandpa round.
pub fn voter_set() -> VoterSet<AuthorityId> {
    VoterSet::new(authority_list()).unwrap()
}

/// Convenience function to get a list of Grandpa authorities.
pub fn authority_list() -> AuthorityList {
    test_keyring()
        .iter()
        .map(|(id, w)| (AuthorityId::from(*id), *w))
        .collect()
}

/// Convenience function to get a list of Grandpa authority addresses.
pub fn authorities() -> Vec<AuthorityId> {
    test_keyring()
        .iter()
        .map(|(id, _w)| AuthorityId::from(*id))
        .collect()
}

/// Get the corresponding identities from the keyring for the "standard" authority set.
pub fn test_keyring() -> Vec<(Account, AuthorityWeight)> {
    vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1)]
}

/// Get a list of "unique" accounts.
pub fn accounts(len: u16) -> Vec<Account> {
    (0..len).map(Account).collect()
}