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
// This file is part of Substrate. // Copyright (C) 2019-2020 Parity Technologies (UK) Ltd. // SPDX-License-Identifier: Apache-2.0 // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //! Substrate core types around sessions. #![cfg_attr(not(feature = "std"), no_std)] use codec::{Encode, Decode}; #[cfg(feature = "std")] use sp_runtime::{generic::BlockId, traits::Block as BlockT}; #[cfg(feature = "std")] use sp_api::ProvideRuntimeApi; use sp_core::RuntimeDebug; use sp_core::crypto::KeyTypeId; use sp_staking::SessionIndex; use sp_std::vec::Vec; sp_api::decl_runtime_apis! { /// Session keys runtime api. pub trait SessionKeys { /// Generate a set of session keys with optionally using the given seed. /// The keys should be stored within the keystore exposed via runtime /// externalities. /// /// The seed needs to be a valid `utf8` string. /// /// Returns the concatenated SCALE encoded public keys. fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8>; /// Decode the given public session keys. /// /// Returns the list of public raw public keys + key type. fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, KeyTypeId)>>; } } /// Number of validators in a given session. pub type ValidatorCount = u32; /// Proof of membership of a specific key in a given session. #[derive(Encode, Decode, Clone, Eq, PartialEq, Default, RuntimeDebug)] pub struct MembershipProof { /// The session index on which the specific key is a member. pub session: SessionIndex, /// Trie nodes of a merkle proof of session membership. pub trie_nodes: Vec<Vec<u8>>, /// The validator count of the session on which the specific key is a member. pub validator_count: ValidatorCount, } /// Generate the initial session keys with the given seeds, at the given block and store them in /// the client's keystore. #[cfg(feature = "std")] pub fn generate_initial_session_keys<Block, T>( client: std::sync::Arc<T>, at: &BlockId<Block>, seeds: Vec<String>, ) -> Result<(), sp_api::ApiErrorFor<T, Block>> where Block: BlockT, T: ProvideRuntimeApi<Block>, T::Api: SessionKeys<Block>, { let runtime_api = client.runtime_api(); for seed in seeds { runtime_api.generate_session_keys(at, Some(seed.as_bytes().to_vec()))?; } Ok(()) }