,
40 | // Could have a skip_prediction field here if it becomes desireable
41 | /// Additional digests provider
42 | pub additional_digests_provider: DP,
43 |
44 | pub _phantom: PhantomData,
45 | }
46 |
47 | impl ConsensusDataProvider for NimbusManualSealConsensusDataProvider
48 | where
49 | B: BlockT,
50 | C: ProvideRuntimeApi + Send + Sync,
51 | C::Api: NimbusApi,
52 | DP: DigestsProvider::Hash> + Send + Sync,
53 | P: Send + Sync,
54 | {
55 | type Transaction = TransactionFor;
56 | type Proof = P;
57 |
58 | fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result {
59 | // Retrieve the relay chain block number to use as the slot number from the parachain inherent
60 | let slot_number = inherents
61 | .get_data::(&PARACHAIN_INHERENT_IDENTIFIER)
62 | .expect("Parachain inherent should decode correctly")
63 | .expect("Parachain inherent should be present because we are mocking it")
64 | .validation_data
65 | .relay_parent_number;
66 |
67 | // Fetch first eligible key from keystore
68 | let maybe_key = crate::first_eligible_key::(
69 | self.client.clone(),
70 | &*self.keystore,
71 | parent,
72 | // For now we author all blocks in slot zero, which is consistent with how we are
73 | // mocking the relay chain height which the runtime uses for slot beacon.
74 | // This should improve. See https://github.com/PureStake/nimbus/issues/3
75 | slot_number,
76 | );
77 |
78 | // If we aren't eligible, return an appropriate error
79 | match maybe_key {
80 | Some(key) => {
81 | let nimbus_id = NimbusId::from_slice(&key).map_err(|_| {
82 | Error::StringError(String::from("invalid nimbus id (wrong length)"))
83 | })?;
84 | let mut logs = vec![CompatibleDigestItem::nimbus_pre_digest(nimbus_id.clone())];
85 | logs.extend(
86 | self.additional_digests_provider
87 | .provide_digests(nimbus_id, parent.hash()),
88 | );
89 | Ok(Digest { logs })
90 | }
91 | None => Err(Error::StringError(String::from(
92 | "no nimbus keys available to manual seal",
93 | ))),
94 | }
95 | }
96 |
97 | // This is where we actually sign with the nimbus key and attach the seal
98 | fn append_block_import(
99 | &self,
100 | _parent: &B::Header,
101 | params: &mut BlockImportParams,
102 | _inherents: &InherentData,
103 | _proof: Self::Proof,
104 | ) -> Result<(), Error> {
105 | // We have to reconstruct the type-public pair which is only communicated through the pre-runtime digest
106 | let claimed_author = params
107 | .header
108 | .digest()
109 | .logs
110 | .iter()
111 | .find_map(|digest| {
112 | match *digest {
113 | // We do not support the older author inherent in manual seal
114 | DigestItem::PreRuntime(id, ref author_id) if id == NIMBUS_ENGINE_ID => {
115 | Some(author_id.clone())
116 | }
117 | _ => None,
118 | }
119 | })
120 | .expect("Expected one pre-runtime digest that contains author id bytes");
121 |
122 | let nimbus_public = NimbusId::from_slice(&claimed_author)
123 | .map_err(|_| Error::StringError(String::from("invalid nimbus id (wrong length)")))?;
124 |
125 | let sig_digest = crate::seal_header::(
126 | ¶ms.header,
127 | &*self.keystore,
128 | &nimbus_public.to_raw_vec(),
129 | &sr25519::CRYPTO_ID,
130 | );
131 |
132 | params.post_digests.push(sig_digest);
133 |
134 | Ok(())
135 | }
136 | }
137 |
--------------------------------------------------------------------------------
/nimbus-primitives/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "nimbus-primitives"
3 | authors = [ "PureStake" ]
4 | description = "Primitive types and traits used in the Nimbus consensus framework"
5 | edition = "2021"
6 | version = "0.9.0"
7 |
8 | [dependencies]
9 | async-trait = { version = "0.1", optional = true }
10 | parity-scale-codec = { version = "3.0.0", default-features = false, features = [ "derive" ] }
11 |
12 | frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
13 | frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
14 | scale-info = { version = "2.0.0", default-features = false, features = [ "derive" ] }
15 | sp-api = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
16 | sp-application-crypto = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
17 | sp-inherents = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
18 | sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
19 | sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
20 |
21 | frame-benchmarking = { git = "https://github.com/paritytech/substrate", optional = true, default-features = false, branch = "polkadot-v0.9.43" }
22 |
23 | [features]
24 | default = [ "std" ]
25 | std = [
26 | "async-trait",
27 | "frame-support/std",
28 | "frame-system/std",
29 | "parity-scale-codec/std",
30 | "scale-info/std",
31 | "sp-api/std",
32 | "sp-application-crypto/std",
33 | "sp-inherents/std",
34 | "sp-runtime/std",
35 | "sp-std/std",
36 | ]
37 |
38 | runtime-benchmarks = [ "frame-benchmarking", "sp-runtime/runtime-benchmarks" ]
39 |
40 | try-runtime = [ "frame-support/try-runtime" ]
41 |
--------------------------------------------------------------------------------
/nimbus-primitives/src/digests.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! A convenient interface over the digests used in nimbus.
18 | //!
19 | //! Currently Nimbus has two digests;
20 | //! 1. A consensus digest that contains the block author identity
21 | //! This information is copied from the author inehrent.
22 | //! This may be replaced with a pre-runtime digest in the future.
23 | //! 2. A seal digest that contains a signature over the rest of the
24 | //! block including the first digest.
25 |
26 | use crate::{NimbusId, NimbusSignature, NIMBUS_ENGINE_ID};
27 | use parity_scale_codec::Encode;
28 | use sp_runtime::generic::DigestItem;
29 |
30 | /// A digest item which is usable with aura consensus.
31 | pub trait CompatibleDigestItem: Sized {
32 | /// Construct a pre-runtime digest from the given AuthorId
33 | fn nimbus_pre_digest(author: NimbusId) -> Self;
34 |
35 | /// If this item is a nimbus pre-runtime digest, return the author
36 | fn as_nimbus_pre_digest(&self) -> Option;
37 |
38 | /// Construct a seal digest item from the given signature
39 | fn nimbus_seal(signature: NimbusSignature) -> Self;
40 |
41 | /// If this item is a nimbus seal, return the signature.
42 | fn as_nimbus_seal(&self) -> Option;
43 |
44 | /// This will be deprecated in the future
45 | /// Construct a consensus digest from the given AuthorId
46 | fn nimbus_consensus_digest(author: NimbusId) -> Self;
47 |
48 | /// This will be deprecated in the future
49 | /// If this item is a nimbus consensus digest, return the author
50 | fn as_nimbus_consensus_digest(&self) -> Option;
51 | }
52 |
53 | impl CompatibleDigestItem for DigestItem {
54 | fn nimbus_pre_digest(author: NimbusId) -> Self {
55 | DigestItem::PreRuntime(NIMBUS_ENGINE_ID, author.encode())
56 | }
57 |
58 | fn as_nimbus_pre_digest(&self) -> Option {
59 | self.pre_runtime_try_to(&NIMBUS_ENGINE_ID)
60 | }
61 |
62 | fn nimbus_seal(signature: NimbusSignature) -> Self {
63 | DigestItem::Seal(NIMBUS_ENGINE_ID, signature.encode())
64 | }
65 |
66 | fn as_nimbus_seal(&self) -> Option {
67 | self.seal_try_to(&NIMBUS_ENGINE_ID)
68 | }
69 |
70 | // Remove this once deprecated
71 | fn nimbus_consensus_digest(author: NimbusId) -> Self {
72 | DigestItem::Consensus(NIMBUS_ENGINE_ID, author.encode())
73 | }
74 |
75 | // Remove this once deprecated. I don't think it is used anyway.
76 | // Notice that it calls the pre_runtime helper function.
77 | fn as_nimbus_consensus_digest(&self) -> Option {
78 | self.pre_runtime_try_to(&NIMBUS_ENGINE_ID)
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/nimbus-primitives/src/inherents.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | use sp_inherents::{InherentData, InherentIdentifier};
18 |
19 | /// The InherentIdentifier for nimbus's author inherent
20 | pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"author__";
21 |
22 | /// A bare minimum inherent data provider that provides no real data.
23 | /// The inherent is simply used as a way to kick off some computation
24 | /// until https://github.com/paritytech/substrate/pull/10128 lands.
25 | pub struct InherentDataProvider;
26 |
27 | #[cfg(feature = "std")]
28 | #[async_trait::async_trait]
29 | impl sp_inherents::InherentDataProvider for InherentDataProvider {
30 | async fn provide_inherent_data(
31 | &self,
32 | inherent_data: &mut InherentData,
33 | ) -> Result<(), sp_inherents::Error> {
34 | inherent_data.put_data(INHERENT_IDENTIFIER, &())
35 | }
36 |
37 | async fn try_handle_error(
38 | &self,
39 | identifier: &InherentIdentifier,
40 | _error: &[u8],
41 | ) -> Option> {
42 | // Dont' process modules from other inherents
43 | if *identifier != INHERENT_IDENTIFIER {
44 | return None;
45 | }
46 |
47 | // All errors with the author inehrent are fatal
48 | Some(Err(sp_inherents::Error::Application(Box::from(
49 | String::from("Error processing dummy nimbus inherent"),
50 | ))))
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/nimbus-primitives/src/lib.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! Nimbus Consensus Primitives
18 | //!
19 | //! Primitive types and traits for working with the Nimbus consensus framework.
20 | //! This code can be built to no_std for use in the runtime
21 |
22 | #![cfg_attr(not(feature = "std"), no_std)]
23 |
24 | use sp_application_crypto::KeyTypeId;
25 | use sp_runtime::generic::DigestItem;
26 | use sp_runtime::traits::BlockNumberProvider;
27 | use sp_runtime::ConsensusEngineId;
28 | #[cfg(feature = "runtime-benchmarks")]
29 | use sp_std::vec::{self, Vec};
30 |
31 | pub mod digests;
32 | mod inherents;
33 |
34 | pub use digests::CompatibleDigestItem;
35 |
36 | pub use inherents::{InherentDataProvider, INHERENT_IDENTIFIER};
37 |
38 | pub trait DigestsProvider {
39 | type Digests: IntoIterator- ;
40 | fn provide_digests(&self, id: Id, parent: BlockHash) -> Self::Digests;
41 | }
42 |
43 | impl DigestsProvider for () {
44 | type Digests = [DigestItem; 0];
45 | fn provide_digests(&self, _id: Id, _parent: BlockHash) -> Self::Digests {
46 | []
47 | }
48 | }
49 |
50 | impl DigestsProvider for F
51 | where
52 | F: Fn(Id, BlockHash) -> D,
53 | D: IntoIterator
- ,
54 | {
55 | type Digests = D;
56 |
57 | fn provide_digests(&self, id: Id, parent: BlockHash) -> Self::Digests {
58 | (*self)(id, parent)
59 | }
60 | }
61 |
62 | /// The given account ID is the author of the current block.
63 | pub trait EventHandler {
64 | //TODO should we be tking ownership here?
65 | fn note_author(author: Author);
66 | }
67 |
68 | impl EventHandler for () {
69 | fn note_author(_author: T) {}
70 | }
71 |
72 | /// A mechanism for determining the current slot.
73 | /// For now we use u32 as the slot type everywhere. Let's see how long we can get away with that.
74 | pub trait SlotBeacon {
75 | fn slot() -> u32;
76 | #[cfg(feature = "runtime-benchmarks")]
77 | fn set_slot(_slot: u32) {}
78 | }
79 |
80 | /// Anything that can provide a block height can be used as a slot beacon. This could be
81 | /// used in at least two realistic ways.
82 | /// 1. Use your own chain's height as the slot number
83 | /// 2. If you're a parachain, use the relay chain's height as the slot number.
84 | impl> SlotBeacon for T {
85 | fn slot() -> u32 {
86 | Self::current_block_number()
87 | }
88 | #[cfg(feature = "runtime-benchmarks")]
89 | fn set_slot(slot: u32) {
90 | Self::set_block_number(slot);
91 | }
92 | }
93 |
94 | /// PLANNED: A SlotBeacon that starts a new slot based on the timestamp. Behaviorally, this is
95 | /// similar to what aura, babe and company do. Implementation-wise it is different because it
96 | /// depends on the timestamp pallet for its notion of time.
97 | pub struct IntervalBeacon;
98 |
99 | impl SlotBeacon for IntervalBeacon {
100 | fn slot() -> u32 {
101 | todo!()
102 | }
103 | }
104 |
105 | /// Trait to determine whether this author is eligible to author in this slot.
106 | /// This is the primary trait your nimbus filter needs to implement.
107 | ///
108 | /// This is the proposition-logic variant.
109 | /// That is to say the caller specifies an author an author and the implementation
110 | /// replies whether that author is eligible. This is useful in many cases and is
111 | /// particularly useful when the active set is unbounded.
112 | /// There may be another variant where the caller only supplies a slot and the
113 | /// implementation replies with a complete set of eligible authors.
114 | pub trait CanAuthor {
115 | #[cfg(feature = "try-runtime")]
116 | // With `try-runtime` the local author should always be able to author a block.
117 | fn can_author(author: &AuthorId, slot: &u32) -> bool {
118 | true
119 | }
120 | #[cfg(not(feature = "try-runtime"))]
121 | fn can_author(author: &AuthorId, slot: &u32) -> bool;
122 | #[cfg(feature = "runtime-benchmarks")]
123 | fn get_authors(_slot: &u32) -> Vec {
124 | vec![]
125 | }
126 | #[cfg(feature = "runtime-benchmarks")]
127 | fn set_eligible_author(_slot: &u32) {}
128 | }
129 | /// Default implementation where anyone can author.
130 | ///
131 | /// This is identical to Cumulus's RelayChainConsensus
132 | impl CanAuthor for () {
133 | fn can_author(_: &T, _: &u32) -> bool {
134 | true
135 | }
136 | }
137 |
138 | /// A Trait to lookup runtime AccountIds from AuthorIds (probably NimbusIds)
139 | /// The trait is generic over the AccountId, becuase different runtimes use
140 | /// different notions of AccoutId. It is also generic over the AuthorId to
141 | /// support the usecase where the author inherent is used for beneficiary info
142 | /// and contains an AccountId directly.
143 | pub trait AccountLookup {
144 | fn lookup_account(author: &NimbusId) -> Option;
145 | }
146 |
147 | // A dummy impl used in simple tests
148 | impl AccountLookup for () {
149 | fn lookup_account(_: &NimbusId) -> Option {
150 | None
151 | }
152 | }
153 |
154 | /// The ConsensusEngineId for nimbus consensus
155 | /// this same identifier will be used regardless of the filters installed
156 | pub const NIMBUS_ENGINE_ID: ConsensusEngineId = *b"nmbs";
157 |
158 | /// The KeyTypeId used in the Nimbus consensus framework regardles of wat filters are in place.
159 | /// If this gets well adopted, we could move this definition to sp_core to avoid conflicts.
160 | pub const NIMBUS_KEY_ID: KeyTypeId = KeyTypeId(*b"nmbs");
161 |
162 | // The strongly-typed crypto wrappers to be used by Nimbus in the keystore
163 | mod nimbus_crypto {
164 | use sp_application_crypto::{app_crypto, sr25519};
165 | app_crypto!(sr25519, crate::NIMBUS_KEY_ID);
166 | }
167 |
168 | /// A nimbus author identifier (A public key).
169 | pub type NimbusId = nimbus_crypto::Public;
170 |
171 | /// A nimbus signature.
172 | pub type NimbusSignature = nimbus_crypto::Signature;
173 |
174 | sp_application_crypto::with_pair! {
175 | /// A nimbus keypair
176 | pub type NimbusPair = nimbus_crypto::Pair;
177 | }
178 |
179 | sp_api::decl_runtime_apis! {
180 | /// The runtime api used to predict whether a Nimbus author will be eligible in the given slot
181 | pub trait NimbusApi {
182 | fn can_author(author: NimbusId, relay_parent: u32, parent_header: &Block::Header) -> bool;
183 | }
184 | }
185 |
--------------------------------------------------------------------------------
/pallets/aura-style-filter/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "pallet-aura-style-filter"
3 | authors = [ "PureStake" ]
4 | description = "The Aura (authority round) consensus engine implemented in the Nimbus framework"
5 | edition = "2021"
6 | version = "0.9.0"
7 |
8 | [dependencies]
9 | frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
10 | frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
11 | nimbus-primitives = { path = "../../nimbus-primitives", default-features = false }
12 | parity-scale-codec = { version = "3.0.0", default-features = false, features = [ "derive" ] }
13 | scale-info = { version = "2.0.0", default-features = false, features = [ "derive" ] }
14 | serde = { version = "1.0.101", optional = true, features = [ "derive" ] }
15 | sp-core = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
16 | sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
17 | sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
18 |
19 | [features]
20 | default = [ "std" ]
21 | std = [
22 | "frame-support/std",
23 | "frame-system/std",
24 | "nimbus-primitives/std",
25 | "parity-scale-codec/std",
26 | "scale-info/std",
27 | "serde",
28 | "sp-core/std",
29 | "sp-runtime/std",
30 | "sp-std/std",
31 | ]
32 |
33 | try-runtime = [ "frame-support/try-runtime", "nimbus-primitives/try-runtime" ]
34 |
--------------------------------------------------------------------------------
/pallets/aura-style-filter/src/lib.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! A Nimbus filter for the AuRa consensus algorithm. This filter does not use any entropy, it
18 | //! simply rotates authors in order. A single author is eligible at each slot.
19 | //!
20 | //! In the Substrate ecosystem, this algorithm is typically known as AuRa (authority round).
21 | //! There is a well known implementation in the main Substrate repository and published at
22 | //! https://crates.io/crates/sc-consensus-aura. There are two primary differences between
23 | //! the approaches:
24 | //!
25 | //! 1. This filter leverages all the heavy lifting of the Nimbus framework and consequently is
26 | //! capable of expressing Aura in < 100 lines of code.
27 | //!
28 | //! Whereas sc-consensus-aura includes the entire consensus stack including block signing, digest
29 | //! formats, and slot prediction. This is a lot of overhead for a sipmle round robin
30 | //! consensus that basically boils down to this function
31 | //! https://github.com/paritytech/substrate/blob/0f849efc/client/consensus/aura/src/lib.rs#L91-L106
32 | //!
33 | //! 2. The Nimbus framework places the author checking logic in the runtime which makes it relatively
34 | //! easy for relay chain validators to confirm the author is valid.
35 | //!
36 | //! Whereas sc-consensus-aura places the author checking offchain. The offchain approach is fine
37 | //! for standalone layer 1 blockchains, but not well suited for verification on the relay chain
38 | //! where validators only run a wasm blob.
39 |
40 | #![cfg_attr(not(feature = "std"), no_std)]
41 |
42 | use frame_support::pallet;
43 | pub use pallet::*;
44 |
45 | #[pallet]
46 | pub mod pallet {
47 |
48 | use frame_support::pallet_prelude::*;
49 | use sp_std::vec::Vec;
50 |
51 | //TODO Now that the CanAuthor trait takes a slot number, I don't think this even needs to be a pallet.
52 | // I think it could eb jsut a simple type.
53 | /// The Author Filter pallet
54 | #[pallet::pallet]
55 | pub struct Pallet(PhantomData);
56 |
57 | /// Configuration trait of this pallet.
58 | #[pallet::config]
59 | pub trait Config: frame_system::Config {
60 | /// A source for the complete set of potential authors.
61 | /// The starting point of the filtering.
62 | type PotentialAuthors: Get>;
63 | }
64 |
65 | // This code will be called by the author-inherent pallet to check whether the reported author
66 | // of this block is eligible at this slot. We calculate that result on demand and do not
67 | // record it instorage.
68 | impl nimbus_primitives::CanAuthor for Pallet {
69 | #[cfg(not(feature = "try-runtime"))]
70 | fn can_author(account: &T::AccountId, slot: &u32) -> bool {
71 | let active: Vec = T::PotentialAuthors::get();
72 |
73 | // This is the core Aura logic right here.
74 | let active_author = &active[*slot as usize % active.len()];
75 |
76 | account == active_author
77 | }
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/pallets/author-inherent/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "pallet-author-inherent"
3 | authors = [ "PureStake" ]
4 | description = "This pallet is the core of the in-runtime portion of Nimbus."
5 | edition = "2021"
6 | license = "GPL-3.0-only"
7 | version = "0.9.0"
8 |
9 | [dependencies]
10 | frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
11 | frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
12 | log = { version = "0.4.17", default-features = false }
13 | nimbus-primitives = { path = "../../nimbus-primitives", default-features = false }
14 | parity-scale-codec = { version = "3.0.0", default-features = false, features = [ "derive" ] }
15 | scale-info = { version = "2.0.0", default-features = false, features = [ "derive" ] }
16 | sp-api = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
17 | sp-application-crypto = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
18 | sp-inherents = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
19 | sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
20 | sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
21 |
22 | # Benchmarks
23 | frame-benchmarking = { git = "https://github.com/paritytech/substrate", optional = true, default-features = false, branch = "polkadot-v0.9.43" }
24 |
25 | [dev-dependencies]
26 | frame-support-test = { git = "https://github.com/paritytech/substrate", version = "3.0.0", branch = "polkadot-v0.9.43" }
27 | sp-core = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
28 | sp-io = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
29 |
30 | [features]
31 | default = [ "std" ]
32 | std = [
33 | "frame-benchmarking/std",
34 | "frame-support/std",
35 | "frame-system/std",
36 | "log/std",
37 | "nimbus-primitives/std",
38 | "parity-scale-codec/std",
39 | "scale-info/std",
40 | "sp-api/std",
41 | "sp-application-crypto/std",
42 | "sp-inherents/std",
43 | "sp-runtime/std",
44 | "sp-std/std",
45 | ]
46 |
47 | runtime-benchmarks = [
48 | "frame-benchmarking",
49 | "nimbus-primitives/runtime-benchmarks",
50 | ]
51 |
--------------------------------------------------------------------------------
/pallets/author-inherent/src/benchmarks.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Moonbeam.
3 |
4 | // Moonbeam is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Moonbeam is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Moonbeam. If not, see .
16 |
17 | #![cfg(feature = "runtime-benchmarks")]
18 |
19 | use crate::{Call, Config, Pallet};
20 | use frame_benchmarking::benchmarks;
21 | use frame_system::RawOrigin;
22 | use nimbus_primitives::CanAuthor;
23 | use nimbus_primitives::SlotBeacon;
24 | benchmarks! {
25 | kick_off_authorship_validation {
26 | // The slot inserted needs to be higher than that already in storage
27 | T::SlotBeacon::set_slot(100);
28 | Pallet::::set_eligible_author(&T::SlotBeacon::slot());
29 | }: _(RawOrigin::None)
30 | }
31 |
--------------------------------------------------------------------------------
/pallets/author-inherent/src/exec.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! Block executive to be used by relay chain validators when validating parachain blocks built
18 | //! with the nimubs consensus family.
19 |
20 | use frame_support::traits::ExecuteBlock;
21 | use sp_api::{BlockT, HeaderT};
22 | // For some reason I can't get these logs to actually print
23 | use log::debug;
24 | use nimbus_primitives::{digests::CompatibleDigestItem, NimbusId, NIMBUS_ENGINE_ID};
25 | use sp_application_crypto::ByteArray;
26 | use sp_runtime::{generic::DigestItem, RuntimeAppPublic};
27 |
28 | /// Block executive to be used by relay chain validators when validating parachain blocks built
29 | /// with the nimubs consensus family.
30 | ///
31 | /// This will strip the seal digest, and confirm that it contains a valid signature
32 | /// By the block author reported in the author inherent.
33 | ///
34 | /// Essentially this contains the logic of the verifier plus the inner executive.
35 | /// TODO Degisn improvement:
36 | /// Can we share code with the verifier?
37 | /// Can this struct take a verifier as an associated type?
38 | /// Or maybe this will just get simpler in general when https://github.com/paritytech/polkadot/issues/2888 lands
39 | pub struct BlockExecutor(sp_std::marker::PhantomData<(T, I)>);
40 |
41 | impl ExecuteBlock for BlockExecutor
42 | where
43 | Block: BlockT,
44 | I: ExecuteBlock,
45 | {
46 | fn execute_block(block: Block) {
47 | let (mut header, extrinsics) = block.deconstruct();
48 |
49 | debug!(target: "executive", "In hacked Executive. Initial digests are {:?}", header.digest());
50 |
51 | // Set the seal aside for checking.
52 | let seal = header
53 | .digest_mut()
54 | .pop()
55 | .expect("Seal digest is present and is last item");
56 |
57 | debug!(target: "executive", "In hacked Executive. digests after stripping {:?}", header.digest());
58 | debug!(target: "executive", "The seal we got {:?}", seal);
59 |
60 | let signature = seal
61 | .as_nimbus_seal()
62 | .unwrap_or_else(|| panic!("HeaderUnsealed"));
63 |
64 | debug!(target: "executive", "🪲 Header hash after popping digest {:?}", header.hash());
65 |
66 | debug!(target: "executive", "🪲 Signature according to executive is {:?}", signature);
67 |
68 | // Grab the author information from the preruntime digest
69 | //TODO use the trait
70 | let claimed_author = header
71 | .digest()
72 | .logs
73 | .iter()
74 | .find_map(|digest| match *digest {
75 | DigestItem::PreRuntime(id, ref author_id) if id == NIMBUS_ENGINE_ID => {
76 | Some(author_id.clone())
77 | }
78 | _ => None,
79 | })
80 | .expect("Expected pre-runtime digest that contains author id bytes");
81 |
82 | debug!(target: "executive", "🪲 Claimed Author according to executive is {:?}", claimed_author);
83 |
84 | // Verify the signature
85 | let valid_signature = NimbusId::from_slice(&claimed_author)
86 | .expect("Expected claimed author to be a valid NimbusId.")
87 | .verify(&header.hash(), &signature);
88 |
89 | debug!(target: "executive", "🪲 Valid signature? {:?}", valid_signature);
90 |
91 | if !valid_signature {
92 | panic!("Block signature invalid");
93 | }
94 |
95 | // Now that we've verified the signature, hand execution off to the inner executor
96 | // which is probably the normal frame executive.
97 | I::execute_block(Block::new(header, extrinsics));
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/pallets/author-inherent/src/lib.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! Pallet that allows block authors to include their identity in a block via an inherent.
18 | //! Currently the author does not _prove_ their identity, just states it. So it should not be used,
19 | //! for things like equivocation slashing that require authenticated authorship information.
20 |
21 | #![cfg_attr(not(feature = "std"), no_std)]
22 |
23 | use frame_support::traits::{FindAuthor, Get};
24 | use nimbus_primitives::{
25 | AccountLookup, CanAuthor, NimbusId, SlotBeacon, INHERENT_IDENTIFIER, NIMBUS_ENGINE_ID,
26 | };
27 | use parity_scale_codec::{Decode, Encode, FullCodec};
28 | use sp_inherents::{InherentIdentifier, IsFatalError};
29 | use sp_runtime::{ConsensusEngineId, RuntimeString};
30 |
31 | mod exec;
32 | pub use exec::BlockExecutor;
33 |
34 | pub use pallet::*;
35 |
36 | #[cfg(any(test, feature = "runtime-benchmarks"))]
37 | mod benchmarks;
38 |
39 | pub mod weights;
40 |
41 | #[cfg(test)]
42 | mod mock;
43 | #[cfg(test)]
44 | mod tests;
45 |
46 | #[frame_support::pallet]
47 | pub mod pallet {
48 | use super::*;
49 | use crate::weights::WeightInfo;
50 | use frame_support::pallet_prelude::*;
51 | use frame_system::pallet_prelude::*;
52 |
53 | /// The Author Inherent pallet. The core of the nimbus consensus framework's runtime presence.
54 | #[pallet::pallet]
55 | pub struct Pallet(PhantomData);
56 |
57 | #[pallet::config]
58 | pub trait Config: frame_system::Config {
59 | /// Type used to refer to a block author.
60 | type AuthorId: sp_std::fmt::Debug + PartialEq + Clone + FullCodec + TypeInfo + MaxEncodedLen;
61 |
62 | /// A type to convert between NimbusId and AuthorId. This is useful when you want to associate
63 | /// Block authoring behavior with an AuthorId for rewards or slashing. If you do not need to
64 | /// hold an AuthorId responsible for authoring use `()` which acts as an identity mapping.
65 | type AccountLookup: AccountLookup;
66 |
67 | /// The final word on whether the reported author can author at this height.
68 | /// This will be used when executing the inherent. This check is often stricter than the
69 | /// Preliminary check, because it can use more data.
70 | /// If the pallet that implements this trait depends on an inherent, that inherent **must**
71 | /// be included before this one.
72 | type CanAuthor: CanAuthor;
73 |
74 | /// Some way of determining the current slot for purposes of verifying the author's eligibility
75 | type SlotBeacon: SlotBeacon;
76 |
77 | type WeightInfo: WeightInfo;
78 | }
79 |
80 | impl sp_runtime::BoundToRuntimeAppPublic for Pallet {
81 | type Public = NimbusId;
82 | }
83 |
84 | #[pallet::error]
85 | pub enum Error {
86 | /// Author already set in block.
87 | AuthorAlreadySet,
88 | /// No AccountId was found to be associated with this author
89 | NoAccountId,
90 | /// The author in the inherent is not an eligible author.
91 | CannotBeAuthor,
92 | }
93 |
94 | /// Author of current block.
95 | #[pallet::storage]
96 | pub type Author = StorageValue<_, T::AuthorId, OptionQuery>;
97 |
98 | /// The highest slot that has been seen in the history of this chain.
99 | /// This is a strictly-increasing value.
100 | #[pallet::storage]
101 | pub type HighestSlotSeen = StorageValue<_, u32, ValueQuery>;
102 |
103 | #[pallet::hooks]
104 | impl Hooks> for Pallet {
105 | fn on_initialize(_: T::BlockNumber) -> Weight {
106 | // Now extract the author from the digest
107 | let digest = >::digest();
108 | let pre_runtime_digests = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
109 | if let Some(author) = Self::find_author(pre_runtime_digests) {
110 | // Store the author so we can confirm eligibility after the inherents have executed
111 | >::put(&author);
112 | }
113 |
114 | T::DbWeight::get().writes(1)
115 | }
116 | }
117 |
118 | #[pallet::call]
119 | impl Pallet {
120 | /// This inherent is a workaround to run code after the "real" inherents have executed,
121 | /// but before transactions are executed.
122 | // This should go into on_post_inherents when it is ready https://github.com/paritytech/substrate/pull/10128
123 | // TODO better weight. For now we just set a somewhat conservative fudge factor
124 | #[pallet::call_index(0)]
125 | #[pallet::weight((T::WeightInfo::kick_off_authorship_validation(), DispatchClass::Mandatory))]
126 | pub fn kick_off_authorship_validation(origin: OriginFor) -> DispatchResultWithPostInfo {
127 | ensure_none(origin)?;
128 |
129 | // First check that the slot number is valid (greater than the previous highest)
130 | let slot = T::SlotBeacon::slot();
131 | assert!(
132 | slot > HighestSlotSeen::::get(),
133 | "Block invalid; Supplied slot number is not high enough"
134 | );
135 |
136 | // Now check that the author is valid in this slot
137 | assert!(
138 | T::CanAuthor::can_author(&Self::get(), &slot),
139 | "Block invalid, supplied author is not eligible."
140 | );
141 |
142 | // Once that is validated, update the stored slot number
143 | HighestSlotSeen::::put(slot);
144 |
145 | Ok(Pays::No.into())
146 | }
147 | }
148 |
149 | #[pallet::inherent]
150 | impl ProvideInherent for Pallet {
151 | type Call = Call;
152 | type Error = InherentError;
153 | const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
154 |
155 | fn is_inherent_required(_: &InherentData) -> Result, Self::Error> {
156 | // Return Ok(Some(_)) unconditionally because this inherent is required in every block
157 | // If it is not found, throw an AuthorInherentRequired error.
158 | Ok(Some(InherentError::Other(
159 | sp_runtime::RuntimeString::Borrowed(
160 | "Inherent required to manually initiate author validation",
161 | ),
162 | )))
163 | }
164 |
165 | // Regardless of whether the client is still supplying the author id,
166 | // we will create the new empty-payload inherent extrinsic.
167 | fn create_inherent(_data: &InherentData) -> Option {
168 | Some(Call::kick_off_authorship_validation {})
169 | }
170 |
171 | fn is_inherent(call: &Self::Call) -> bool {
172 | matches!(call, Call::kick_off_authorship_validation { .. })
173 | }
174 | }
175 |
176 | impl FindAuthor for Pallet {
177 | fn find_author<'a, I>(digests: I) -> Option
178 | where
179 | I: 'a + IntoIterator
- ,
180 | {
181 | for (id, mut data) in digests.into_iter() {
182 | if id == NIMBUS_ENGINE_ID {
183 | let author_id = NimbusId::decode(&mut data)
184 | .expect("NimbusId encoded in preruntime digest must be valid");
185 |
186 | let author_account = T::AccountLookup::lookup_account(&author_id)
187 | .expect("No Account Mapped to this NimbusId");
188 |
189 | return Some(author_account);
190 | }
191 | }
192 |
193 | None
194 | }
195 | }
196 |
197 | impl Get for Pallet {
198 | fn get() -> T::AuthorId {
199 | Author::::get().expect("Block author not inserted into Author Inherent Pallet")
200 | }
201 | }
202 |
203 | /// To learn whether a given NimbusId can author, as opposed to an account id, you
204 | /// can ask this pallet directly. It will do the mapping for you.
205 | impl CanAuthor for Pallet {
206 | fn can_author(author: &NimbusId, slot: &u32) -> bool {
207 | let account = match T::AccountLookup::lookup_account(author) {
208 | Some(account) => account,
209 | // Authors whose account lookups fail will not be eligible
210 | None => {
211 | return false;
212 | }
213 | };
214 |
215 | T::CanAuthor::can_author(&account, slot)
216 | }
217 | #[cfg(feature = "runtime-benchmarks")]
218 | fn set_eligible_author(slot: &u32) {
219 | let eligible_authors = T::CanAuthor::get_authors(slot);
220 | if let Some(author) = eligible_authors.first() {
221 | Author::::put(author)
222 | }
223 | }
224 | }
225 | }
226 |
227 | #[derive(Encode)]
228 | #[cfg_attr(feature = "std", derive(Debug, Decode))]
229 | pub enum InherentError {
230 | Other(RuntimeString),
231 | }
232 |
233 | impl IsFatalError for InherentError {
234 | fn is_fatal_error(&self) -> bool {
235 | match *self {
236 | InherentError::Other(_) => true,
237 | }
238 | }
239 | }
240 |
241 | impl InherentError {
242 | /// Try to create an instance ouf of the given identifier and data.
243 | #[cfg(feature = "std")]
244 | pub fn try_from(id: &InherentIdentifier, data: &[u8]) -> Option {
245 | if id == &INHERENT_IDENTIFIER {
246 | ::decode(&mut &data[..]).ok()
247 | } else {
248 | None
249 | }
250 | }
251 | }
252 |
--------------------------------------------------------------------------------
/pallets/author-inherent/src/mock.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | use crate::{self as pallet_testing, AccountLookup, NimbusId};
18 | use frame_support::parameter_types;
19 | use frame_support::traits::ConstU32;
20 | use frame_support::weights::RuntimeDbWeight;
21 | use frame_system;
22 | use sp_core::H256;
23 | use sp_runtime::{
24 | testing::Header,
25 | traits::{BlakeTwo256, IdentityLookup},
26 | };
27 |
28 | type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic;
29 | type Block = frame_system::mocking::MockBlock;
30 |
31 | frame_support::construct_runtime!(
32 | pub enum Test where
33 | Block = Block,
34 | NodeBlock = Block,
35 | UncheckedExtrinsic = UncheckedExtrinsic,
36 | {
37 | System: frame_system::{Pallet, Call, Config, Storage, Event},
38 | AuthorInherent: pallet_testing::{Pallet, Call, Storage},
39 | }
40 | );
41 |
42 | parameter_types! {
43 | pub const BlockHashCount: u64 = 250;
44 | pub Authors: Vec = vec![1, 2, 3, 4, 5];
45 | pub const TestDbWeight: RuntimeDbWeight = RuntimeDbWeight {
46 | read: 1,
47 | write: 10,
48 | };
49 | }
50 |
51 | impl frame_system::Config for Test {
52 | type BaseCallFilter = frame_support::traits::Everything;
53 | type BlockWeights = ();
54 | type BlockLength = ();
55 | type DbWeight = TestDbWeight;
56 | type RuntimeOrigin = RuntimeOrigin;
57 | type RuntimeCall = RuntimeCall;
58 | type Index = u64;
59 | type BlockNumber = u64;
60 | type Hash = H256;
61 | type Hashing = BlakeTwo256;
62 | type AccountId = u64;
63 | type Lookup = IdentityLookup;
64 | type Header = Header;
65 | type RuntimeEvent = RuntimeEvent;
66 | type BlockHashCount = BlockHashCount;
67 | type Version = ();
68 | type PalletInfo = PalletInfo;
69 | type AccountData = ();
70 | type OnNewAccount = ();
71 | type OnKilledAccount = ();
72 | type SystemWeightInfo = ();
73 | type SS58Prefix = ();
74 | type OnSetCode = ();
75 | type MaxConsumers = ConstU32<16>;
76 | }
77 |
78 | pub struct DummyBeacon {}
79 | impl nimbus_primitives::SlotBeacon for DummyBeacon {
80 | fn slot() -> u32 {
81 | 0
82 | }
83 | }
84 |
85 | pub const ALICE: u64 = 1;
86 | pub const ALICE_NIMBUS: [u8; 32] = [1; 32];
87 | pub struct MockAccountLookup;
88 | impl AccountLookup for MockAccountLookup {
89 | fn lookup_account(nimbus_id: &NimbusId) -> Option {
90 | let nimbus_id_bytes: &[u8] = nimbus_id.as_ref();
91 |
92 | if nimbus_id_bytes == &ALICE_NIMBUS {
93 | Some(ALICE)
94 | } else {
95 | None
96 | }
97 | }
98 | }
99 |
100 | impl pallet_testing::Config for Test {
101 | type AuthorId = u64;
102 | type AccountLookup = MockAccountLookup;
103 | type CanAuthor = ();
104 | type SlotBeacon = DummyBeacon;
105 | type WeightInfo = ();
106 | }
107 |
108 | /// Build genesis storage according to the mock runtime.
109 | pub fn new_test_ext() -> sp_io::TestExternalities {
110 | frame_system::GenesisConfig::default()
111 | .build_storage::()
112 | .unwrap()
113 | .into()
114 | }
115 |
--------------------------------------------------------------------------------
/pallets/author-inherent/src/tests.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | use crate::mock::*;
18 | use crate::pallet::Author;
19 | use frame_support::traits::{OnFinalize, OnInitialize};
20 | use nimbus_primitives::{NimbusId, NIMBUS_ENGINE_ID};
21 | use parity_scale_codec::Encode;
22 | use sp_core::{ByteArray, H256};
23 | use sp_runtime::{Digest, DigestItem};
24 |
25 | #[test]
26 | fn kick_off_authorship_validation_is_mandatory() {
27 | use frame_support::dispatch::{DispatchClass, GetDispatchInfo};
28 |
29 | let info = crate::Call::::kick_off_authorship_validation {}.get_dispatch_info();
30 | assert_eq!(info.class, DispatchClass::Mandatory);
31 | }
32 |
33 | #[test]
34 | fn test_author_is_available_after_on_initialize() {
35 | new_test_ext().execute_with(|| {
36 | let block_number = 1;
37 | System::initialize(
38 | &block_number,
39 | &H256::default(),
40 | &Digest {
41 | logs: vec![DigestItem::PreRuntime(
42 | NIMBUS_ENGINE_ID,
43 | NimbusId::from_slice(&ALICE_NIMBUS).unwrap().encode(),
44 | )],
45 | },
46 | );
47 |
48 | AuthorInherent::on_initialize(block_number);
49 | assert_eq!(Some(ALICE), >::get());
50 | });
51 | }
52 |
53 | #[test]
54 | fn test_author_is_still_available_after_on_finalize() {
55 | new_test_ext().execute_with(|| {
56 | let block_number = 1;
57 | System::initialize(
58 | &block_number,
59 | &H256::default(),
60 | &Digest {
61 | logs: vec![DigestItem::PreRuntime(
62 | NIMBUS_ENGINE_ID,
63 | NimbusId::from_slice(&ALICE_NIMBUS).unwrap().encode(),
64 | )],
65 | },
66 | );
67 |
68 | AuthorInherent::on_initialize(block_number);
69 | AuthorInherent::on_finalize(block_number);
70 | assert_eq!(Some(ALICE), >::get());
71 | });
72 | }
73 |
--------------------------------------------------------------------------------
/pallets/author-inherent/src/weights.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Moonbeam.
3 |
4 | // Moonbeam is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Moonbeam is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Moonbeam. If not, see .
16 |
17 |
18 | //! Autogenerated weights for pallet_author_inherent
19 | //!
20 | //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
21 | //! DATE: 2023-05-02, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
22 | //! WORST CASE MAP SIZE: `1000000`
23 | //! HOSTNAME: `benchmarker`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
24 | //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
25 |
26 | // Executed Command:
27 | // ./target/release/moonbeam
28 | // benchmark
29 | // pallet
30 | // --execution=wasm
31 | // --wasm-execution=compiled
32 | // --pallet
33 | // *
34 | // --extrinsic
35 | // *
36 | // --steps
37 | // 50
38 | // --repeat
39 | // 20
40 | // --template=./benchmarking/frame-weight-template.hbs
41 | // --json-file
42 | // raw.json
43 | // --output
44 | // weights/
45 |
46 | #![cfg_attr(rustfmt, rustfmt_skip)]
47 | #![allow(unused_parens)]
48 | #![allow(unused_imports)]
49 |
50 | use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
51 | use sp_std::marker::PhantomData;
52 |
53 | /// Weight functions needed for pallet_author_inherent.
54 | pub trait WeightInfo {
55 | fn kick_off_authorship_validation() -> Weight;
56 | }
57 |
58 | /// Weights for pallet_author_inherent using the Substrate node and recommended hardware.
59 | pub struct SubstrateWeight(PhantomData);
60 | impl WeightInfo for SubstrateWeight {
61 | /// Storage: ParachainSystem ValidationData (r:1 w:0)
62 | /// Proof Skipped: ParachainSystem ValidationData (max_values: Some(1), max_size: None, mode: Measured)
63 | /// Storage: AuthorInherent HighestSlotSeen (r:1 w:1)
64 | /// Proof: AuthorInherent HighestSlotSeen (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
65 | /// Storage: AuthorInherent Author (r:1 w:0)
66 | /// Proof: AuthorInherent Author (max_values: Some(1), max_size: Some(20), added: 515, mode: MaxEncodedLen)
67 | /// Storage: ParachainStaking SelectedCandidates (r:1 w:0)
68 | /// Proof Skipped: ParachainStaking SelectedCandidates (max_values: Some(1), max_size: None, mode: Measured)
69 | /// Storage: AuthorFilter EligibleCount (r:1 w:0)
70 | /// Proof Skipped: AuthorFilter EligibleCount (max_values: Some(1), max_size: None, mode: Measured)
71 | /// Storage: Randomness PreviousLocalVrfOutput (r:1 w:0)
72 | /// Proof Skipped: Randomness PreviousLocalVrfOutput (max_values: Some(1), max_size: None, mode: Measured)
73 | fn kick_off_authorship_validation() -> Weight {
74 | // Proof Size summary in bytes:
75 | // Measured: `371`
76 | // Estimated: `10418`
77 | // Minimum execution time: 25_775_000 picoseconds.
78 | Weight::from_parts(26_398_000, 10418)
79 | .saturating_add(T::DbWeight::get().reads(6_u64))
80 | .saturating_add(T::DbWeight::get().writes(1_u64))
81 | }
82 | }
83 |
84 | // For backwards compatibility and tests
85 | impl WeightInfo for () {
86 | /// Storage: ParachainSystem ValidationData (r:1 w:0)
87 | /// Proof Skipped: ParachainSystem ValidationData (max_values: Some(1), max_size: None, mode: Measured)
88 | /// Storage: AuthorInherent HighestSlotSeen (r:1 w:1)
89 | /// Proof: AuthorInherent HighestSlotSeen (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
90 | /// Storage: AuthorInherent Author (r:1 w:0)
91 | /// Proof: AuthorInherent Author (max_values: Some(1), max_size: Some(20), added: 515, mode: MaxEncodedLen)
92 | /// Storage: ParachainStaking SelectedCandidates (r:1 w:0)
93 | /// Proof Skipped: ParachainStaking SelectedCandidates (max_values: Some(1), max_size: None, mode: Measured)
94 | /// Storage: AuthorFilter EligibleCount (r:1 w:0)
95 | /// Proof Skipped: AuthorFilter EligibleCount (max_values: Some(1), max_size: None, mode: Measured)
96 | /// Storage: Randomness PreviousLocalVrfOutput (r:1 w:0)
97 | /// Proof Skipped: Randomness PreviousLocalVrfOutput (max_values: Some(1), max_size: None, mode: Measured)
98 | fn kick_off_authorship_validation() -> Weight {
99 | // Proof Size summary in bytes:
100 | // Measured: `371`
101 | // Estimated: `10418`
102 | // Minimum execution time: 25_775_000 picoseconds.
103 | Weight::from_parts(26_398_000, 10418)
104 | .saturating_add(RocksDbWeight::get().reads(6_u64))
105 | .saturating_add(RocksDbWeight::get().writes(1_u64))
106 | }
107 | }
--------------------------------------------------------------------------------
/pallets/author-slot-filter/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "pallet-author-slot-filter"
3 | authors = [ "PureStake" ]
4 | description = "Selects a pseudorandom Subset of eligible (probably staked) authors at each slot"
5 | edition = "2021"
6 | version = "0.9.0"
7 |
8 | [dependencies]
9 | frame-support = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
10 | frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
11 | log = { version = "0.4.17", default-features = false }
12 | nimbus-primitives = { path = "../../nimbus-primitives", default-features = false }
13 | parity-scale-codec = { version = "3.0.0", default-features = false, features = [ "derive" ] }
14 | scale-info = { version = "2.0.0", default-features = false, features = [ "derive" ] }
15 | serde = { version = "1.0.101", default-features = false, features = [ "derive" ] }
16 | sp-core = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
17 | sp-runtime = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
18 | sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.43" }
19 |
20 | # Benchmarks
21 | frame-benchmarking = { git = "https://github.com/paritytech/substrate", optional = true, default-features = false, branch = "polkadot-v0.9.43" }
22 |
23 | [dev-dependencies]
24 | frame-support-test = { git = "https://github.com/paritytech/substrate", version = "3.0.0", branch = "polkadot-v0.9.43" }
25 | sp-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.43" }
26 |
27 | [features]
28 | default = [ "std" ]
29 | std = [
30 | "frame-benchmarking/std",
31 | "frame-support/std",
32 | "frame-system/std",
33 | "log/std",
34 | "nimbus-primitives/std",
35 | "parity-scale-codec/std",
36 | "scale-info/std",
37 | "serde/std",
38 | "sp-core/std",
39 | "sp-runtime/std",
40 | "sp-std/std",
41 | ]
42 |
43 | runtime-benchmarks = [ "frame-benchmarking", "nimbus-primitives/runtime-benchmarks" ]
44 |
45 | try-runtime = [ "frame-support/try-runtime", "nimbus-primitives/try-runtime" ]
46 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/benchmarks.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Moonbeam.
3 |
4 | // Moonbeam is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Moonbeam is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Moonbeam. If not, see .
16 |
17 | #![cfg(feature = "runtime-benchmarks")]
18 |
19 | use crate::num::NonZeroU32;
20 | use crate::{Call, Config, Pallet};
21 | use frame_benchmarking::{benchmarks, impl_benchmark_test_suite};
22 | use frame_system::RawOrigin;
23 |
24 | benchmarks! {
25 | set_eligible {
26 | let count = NonZeroU32::new_unchecked(34);
27 | }: _(RawOrigin::Root, count.clone())
28 | verify {
29 | assert_eq!(Pallet::::eligible_count(), count);
30 | }
31 | }
32 |
33 | #[cfg(test)]
34 | mod tests {
35 | use crate::tests::Test;
36 | use sp_io::TestExternalities;
37 |
38 | pub fn new_test_ext() -> TestExternalities {
39 | let t = frame_system::GenesisConfig::default()
40 | .build_storage::()
41 | .unwrap();
42 | TestExternalities::new(t)
43 | }
44 | }
45 |
46 | impl_benchmark_test_suite!(
47 | Pallet,
48 | crate::benchmarks::tests::new_test_ext(),
49 | crate::tests::Test
50 | );
51 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/lib.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! Small pallet responsible determining which accounts are eligible to author at the current
18 | //! slot.
19 | //!
20 | //! Using a randomness beacon supplied by the `Randomness` trait, this pallet takes the set of
21 | //! currently active accounts from an upstream source, and filters them down to a pseudorandom subset.
22 | //! The current technique gives no preference to any particular author. In the future, we could
23 | //! disfavor authors who are authoring a disproportionate amount of the time in an attempt to
24 | //! "even the playing field".
25 |
26 | #![cfg_attr(not(feature = "std"), no_std)]
27 |
28 | use frame_support::pallet;
29 |
30 | pub use pallet::*;
31 |
32 | #[cfg(any(test, feature = "runtime-benchmarks"))]
33 | mod benchmarks;
34 |
35 | pub mod migration;
36 | pub mod num;
37 | pub mod weights;
38 |
39 | #[cfg(test)]
40 | mod mock;
41 | #[cfg(test)]
42 | mod tests;
43 |
44 | #[allow(deprecated)]
45 | #[pallet]
46 | pub mod pallet {
47 |
48 | use crate::num::NonZeroU32;
49 | use crate::weights::WeightInfo;
50 | use frame_support::{pallet_prelude::*, traits::Randomness};
51 | use frame_system::pallet_prelude::*;
52 | use log::debug;
53 | use nimbus_primitives::CanAuthor;
54 | use sp_core::H256;
55 | use sp_runtime::Percent;
56 | use sp_std::vec::Vec;
57 |
58 | /// The Author Filter pallet
59 | #[pallet::pallet]
60 | #[pallet::without_storage_info]
61 | pub struct Pallet(PhantomData);
62 |
63 | /// Configuration trait of this pallet.
64 | #[pallet::config]
65 | pub trait Config: frame_system::Config {
66 | /// The overarching event type
67 | type RuntimeEvent: From + IsType<::RuntimeEvent>;
68 | /// Deterministic on-chain pseudo-randomness used to do the filtering
69 | type RandomnessSource: Randomness;
70 | //TODO introduce a new trait for exhaustive sets and use it here.
71 | // Oh actually, we can use the same trait. First we call the inner one
72 | // to determine whether this particular author is eligible there. then we
73 | // use the author as part of the subject when querying eligibility. I like this better.
74 | /// A source for the complete set of potential authors.
75 | /// The starting point of the filtering.
76 | type PotentialAuthors: Get>;
77 | type WeightInfo: WeightInfo;
78 | }
79 |
80 | /// Compute a pseudo-random subset of the input accounts by using Pallet's
81 | /// source of randomness, `Config::RandomnessSource`.
82 | /// Returns (Eligible, Ineligible), each is a set of accounts
83 | pub fn compute_pseudo_random_subset(
84 | mut active: Vec,
85 | seed: &u32,
86 | ) -> (Vec, Vec) {
87 | let mut num_eligible = EligibleCount::::get().get() as usize;
88 | if num_eligible > active.len() {
89 | num_eligible = active.len();
90 | }
91 |
92 | let mut eligible = Vec::with_capacity(num_eligible);
93 |
94 | for i in 0..num_eligible {
95 | // A context identifier for grabbing the randomness. Consists of three parts
96 | // 1. Constant string *b"filter" - to identify this pallet
97 | // 2. First 2 bytes of index.to_le_bytes when selecting the ith eligible author
98 | // 3. First 4 bytes of seed.to_be_bytes
99 | let mut first_two_bytes_of_index = &i.to_le_bytes()[..2];
100 | let mut first_four_bytes_of_seed = &seed.to_be_bytes()[..4];
101 | let mut constant_string: [u8; 6] = [b'f', b'i', b'l', b't', b'e', b'r'];
102 | let mut subject: [u8; 12] = [0u8; 12];
103 | subject[..6].copy_from_slice(&mut constant_string);
104 | subject[6..8].copy_from_slice(&mut first_two_bytes_of_index);
105 | subject[8..].copy_from_slice(&mut first_four_bytes_of_seed);
106 | let (randomness, _) = T::RandomnessSource::random(&subject);
107 | debug!(target: "author-filter", "🎲Randomness sample {}: {:?}", i, &randomness);
108 |
109 | // Cast to u32 first so we get consistent results on 32- and 64-bit platforms.
110 | let bytes: [u8; 4] = randomness.to_fixed_bytes()[0..4]
111 | .try_into()
112 | .expect("H256 has at least 4 bytes; qed");
113 | let randomness = u32::from_le_bytes(bytes) as usize;
114 |
115 | // Move the selected author from the original vector into the eligible vector
116 | // TODO we could short-circuit this check by returning early when the claimed
117 | // author is selected. For now I'll leave it like this because:
118 | // 1. it is easier to understand what our core filtering logic is
119 | // 2. we currently show the entire filtered set in the debug event
120 | eligible.push(active.remove(randomness % active.len()));
121 | }
122 | (eligible, active)
123 | }
124 |
125 | // This code will be called by the author-inherent pallet to check whether the reported author
126 | // of this block is eligible in this slot. We calculate that result on demand and do not
127 | // record it in storage (although we do emit a debugging event for now).
128 | impl CanAuthor for Pallet {
129 | #[cfg(not(feature = "try-runtime"))]
130 | fn can_author(author: &T::AccountId, slot: &u32) -> bool {
131 | // Compute pseudo-random subset of potential authors
132 | let (eligible, ineligible) =
133 | compute_pseudo_random_subset::(T::PotentialAuthors::get(), slot);
134 |
135 | // Print some logs for debugging purposes.
136 | debug!(target: "author-filter", "Eligible Authors: {:?}", eligible);
137 | debug!(target: "author-filter", "Ineligible Authors: {:?}", &ineligible);
138 | debug!(target: "author-filter",
139 | "Current author, {:?}, is eligible: {}",
140 | author,
141 | eligible.contains(author)
142 | );
143 |
144 | eligible.contains(author)
145 | }
146 | #[cfg(feature = "runtime-benchmarks")]
147 | fn get_authors(slot: &u32) -> Vec {
148 | // Compute pseudo-random subset of potential authors
149 | let (eligible, _) = compute_pseudo_random_subset::(T::PotentialAuthors::get(), slot);
150 | eligible
151 | }
152 | }
153 |
154 | #[pallet::call]
155 | impl Pallet {
156 | /// Update the eligible count. Intended to be called by governance.
157 | #[pallet::call_index(0)]
158 | #[pallet::weight(T::WeightInfo::set_eligible())]
159 | pub fn set_eligible(
160 | origin: OriginFor,
161 | new: EligibilityValue,
162 | ) -> DispatchResultWithPostInfo {
163 | ensure_root(origin)?;
164 | EligibleCount::::put(&new);
165 | >::deposit_event(Event::EligibleUpdated(new));
166 |
167 | Ok(Default::default())
168 | }
169 | }
170 |
171 | /// The type of eligibility to use
172 | pub type EligibilityValue = NonZeroU32;
173 |
174 | impl EligibilityValue {
175 | /// Default total number of eligible authors, must NOT be 0.
176 | pub fn default() -> Self {
177 | NonZeroU32::new_unchecked(50)
178 | }
179 | }
180 |
181 | #[pallet::storage]
182 | #[pallet::getter(fn eligible_ratio)]
183 | #[deprecated(note = "use `pallet::EligibleCount` instead")]
184 | pub type EligibleRatio = StorageValue<_, Percent, ValueQuery, Half>;
185 |
186 | // Default value for the `EligibleRatio` is one half.
187 | #[pallet::type_value]
188 | pub fn Half() -> Percent {
189 | Percent::from_percent(50)
190 | }
191 |
192 | /// The number of active authors that will be eligible at each height.
193 | #[pallet::storage]
194 | #[pallet::getter(fn eligible_count)]
195 | pub type EligibleCount =
196 | StorageValue<_, EligibilityValue, ValueQuery, DefaultEligibilityValue>;
197 |
198 | // Default value for the `EligibleCount`.
199 | #[pallet::type_value]
200 | pub fn DefaultEligibilityValue() -> EligibilityValue {
201 | EligibilityValue::default()
202 | }
203 |
204 | #[pallet::genesis_config]
205 | pub struct GenesisConfig {
206 | pub eligible_count: EligibilityValue,
207 | }
208 |
209 | #[cfg(feature = "std")]
210 | impl Default for GenesisConfig {
211 | fn default() -> Self {
212 | Self {
213 | eligible_count: EligibilityValue::default(),
214 | }
215 | }
216 | }
217 |
218 | #[pallet::genesis_build]
219 | impl GenesisBuild for GenesisConfig {
220 | fn build(&self) {
221 | EligibleCount::::put(self.eligible_count.clone());
222 | }
223 | }
224 |
225 | #[pallet::event]
226 | #[pallet::generate_deposit(fn deposit_event)]
227 | pub enum Event {
228 | /// The amount of eligible authors for the filter to select has been changed.
229 | EligibleUpdated(EligibilityValue),
230 | }
231 | }
232 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/migration.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | use core::marker::PhantomData;
18 | use frame_support::traits::Get;
19 | use frame_support::traits::OnRuntimeUpgrade;
20 | use frame_support::weights::Weight;
21 | use sp_runtime::Percent;
22 |
23 | use super::num::NonZeroU32;
24 | use super::pallet::Config;
25 | use super::pallet::EligibilityValue;
26 | use super::pallet::EligibleCount;
27 | use super::pallet::Pallet;
28 |
29 | #[cfg(feature = "try-runtime")]
30 | use {
31 | parity_scale_codec::{Decode, Encode},
32 | sp_std::vec::Vec,
33 | };
34 |
35 | pub struct EligibleRatioToEligiblityCount(PhantomData);
36 |
37 | impl OnRuntimeUpgrade for EligibleRatioToEligiblityCount
38 | where
39 | T: Config,
40 | {
41 | fn on_runtime_upgrade() -> Weight {
42 | log::info!(target: "EligibleRatioToEligiblityCount", "starting migration");
43 |
44 | let old_value = >::eligible_ratio();
45 | let total_authors = ::PotentialAuthors::get().len();
46 | let new_value = percent_of_num(old_value, total_authors as u32);
47 | let new_value = NonZeroU32::new(new_value).unwrap_or_else(EligibilityValue::default);
48 | >::put(new_value);
49 |
50 | T::DbWeight::get().reads_writes(1, 1)
51 | }
52 |
53 | #[cfg(feature = "try-runtime")]
54 | fn pre_upgrade() -> Result, &'static str> {
55 | let old_value = >::eligible_ratio();
56 |
57 | let total_authors = ::PotentialAuthors::get().len();
58 | let new_value = percent_of_num(old_value, total_authors as u32);
59 | let expected_value = NonZeroU32::new(new_value).unwrap_or_else(EligibilityValue::default);
60 |
61 | Ok(expected_value.encode())
62 | }
63 |
64 | #[cfg(feature = "try-runtime")]
65 | fn post_upgrade(state: Vec) -> Result<(), &'static str> {
66 | let expected: NonZeroU32 =
67 | Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed");
68 |
69 | let actual = >::eligible_count();
70 |
71 | assert_eq!(expected, actual);
72 |
73 | Ok(())
74 | }
75 | }
76 |
77 | fn percent_of_num(percent: Percent, num: u32) -> u32 {
78 | percent.mul_ceil(num as u32)
79 | }
80 |
81 | #[cfg(test)]
82 | mod tests {
83 | use super::percent_of_num;
84 | use super::*;
85 |
86 | #[test]
87 | fn test_percent_of_num_ceils_value() {
88 | let fifty_percent = Percent::from_float(0.5);
89 |
90 | let actual = percent_of_num(fifty_percent, 5);
91 | assert_eq!(3, actual);
92 |
93 | let actual = percent_of_num(fifty_percent, 20);
94 | assert_eq!(10, actual);
95 | }
96 |
97 | #[test]
98 | fn test_percent_of_num_hundred_percent_uses_full_value() {
99 | let one_hundred_percent = Percent::from_float(1.0);
100 |
101 | let actual = percent_of_num(one_hundred_percent, 5);
102 | assert_eq!(5, actual);
103 |
104 | let actual = percent_of_num(one_hundred_percent, 20);
105 | assert_eq!(20, actual);
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/mock.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | use crate as pallet_testing;
18 | use frame_support::parameter_types;
19 | use frame_support::sp_io;
20 | use frame_support::traits::ConstU32;
21 | use frame_support::weights::RuntimeDbWeight;
22 | use frame_support_test::TestRandomness;
23 | use sp_core::H256;
24 | use sp_runtime::{
25 | testing::Header,
26 | traits::{BlakeTwo256, IdentityLookup},
27 | };
28 |
29 | type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic;
30 | type Block = frame_system::mocking::MockBlock;
31 |
32 | frame_support::construct_runtime!(
33 | pub enum Test where
34 | Block = Block,
35 | NodeBlock = Block,
36 | UncheckedExtrinsic = UncheckedExtrinsic,
37 | {
38 | System: frame_system::{Pallet, Call, Config, Storage, Event},
39 | AuthorSlotFilter: pallet_testing::{Pallet, Call, Storage, Event},
40 | }
41 | );
42 |
43 | parameter_types! {
44 | pub const BlockHashCount: u64 = 250;
45 | pub Authors: Vec = vec![1, 2, 3, 4, 5];
46 | pub const TestDbWeight: RuntimeDbWeight = RuntimeDbWeight {
47 | read: 1,
48 | write: 10,
49 | };
50 | }
51 |
52 | impl frame_system::Config for Test {
53 | type BaseCallFilter = frame_support::traits::Everything;
54 | type BlockWeights = ();
55 | type BlockLength = ();
56 | type DbWeight = TestDbWeight;
57 | type RuntimeOrigin = RuntimeOrigin;
58 | type RuntimeCall = RuntimeCall;
59 | type Index = u64;
60 | type BlockNumber = u64;
61 | type Hash = H256;
62 | type Hashing = BlakeTwo256;
63 | type AccountId = u64;
64 | type Lookup = IdentityLookup;
65 | type Header = Header;
66 | type RuntimeEvent = RuntimeEvent;
67 | type BlockHashCount = BlockHashCount;
68 | type Version = ();
69 | type PalletInfo = PalletInfo;
70 | type AccountData = ();
71 | type OnNewAccount = ();
72 | type OnKilledAccount = ();
73 | type SystemWeightInfo = ();
74 | type SS58Prefix = ();
75 | type OnSetCode = ();
76 | type MaxConsumers = ConstU32<16>;
77 | }
78 |
79 | impl pallet_testing::Config for Test {
80 | type RuntimeEvent = RuntimeEvent;
81 | type RandomnessSource = TestRandomness;
82 | type PotentialAuthors = Authors;
83 | type WeightInfo = ();
84 | }
85 |
86 | /// Build genesis storage according to the mock runtime.
87 | pub fn new_test_ext() -> sp_io::TestExternalities {
88 | frame_system::GenesisConfig::default()
89 | .build_storage::()
90 | .unwrap()
91 | .into()
92 | }
93 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/num.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | //! Implements a [NonZeroU32] type that interplays nicely with the
18 | //! subtrate storage and the SCALE codec.
19 |
20 | use parity_scale_codec::{Decode, Encode, Error, Input};
21 | use scale_info::TypeInfo;
22 | use serde::de::Error as DeserializeError;
23 | use serde::{Deserialize, Deserializer, Serialize, Serializer};
24 |
25 | #[derive(Clone, Debug, TypeInfo, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
26 | pub struct NonZeroU32(u32);
27 |
28 | impl core::ops::Deref for NonZeroU32 {
29 | type Target = u32;
30 | fn deref(&self) -> &Self::Target {
31 | &self.0
32 | }
33 | }
34 |
35 | impl parity_scale_codec::EncodeLike for NonZeroU32 {}
36 |
37 | impl NonZeroU32 {
38 | /// Creates a new `Some(NonZeroU32)` instance if value is 0, `None` otherwise.
39 | #[inline]
40 | pub const fn new(n: u32) -> Option {
41 | if n != 0 {
42 | Some(Self(n))
43 | } else {
44 | None
45 | }
46 | }
47 |
48 | /// new_unchecked creats a `NonZeroU32` where the user MUST guarantee
49 | /// that the value is nonzero.
50 | #[inline]
51 | pub const fn new_unchecked(n: u32) -> Self {
52 | Self(n)
53 | }
54 |
55 | /// Returns the the underlying number
56 | pub fn get(&self) -> u32 {
57 | self.0
58 | }
59 | }
60 |
61 | #[cfg(feature = "std")]
62 | impl Serialize for NonZeroU32 {
63 | fn serialize
(&self, serializer: S) -> Result
64 | where
65 | S: Serializer,
66 | {
67 | self.clone().get().serialize(serializer)
68 | }
69 | }
70 |
71 | #[cfg(feature = "std")]
72 | impl<'de> Deserialize<'de> for NonZeroU32 {
73 | fn deserialize(deserializer: D) -> Result
74 | where
75 | D: Deserializer<'de>,
76 | {
77 | let value = Deserialize::deserialize(deserializer)?;
78 | match NonZeroU32::new(value) {
79 | Some(nonzero) => Ok(nonzero),
80 | None => Err(DeserializeError::custom("expected a non-zero value")),
81 | }
82 | }
83 | }
84 |
85 | impl Decode for NonZeroU32 {
86 | fn decode(input: &mut I) -> Result {
87 | Self::new(Decode::decode(input)?)
88 | .ok_or_else(|| Error::from("cannot create non-zero number from 0"))
89 | }
90 | }
91 |
92 | #[cfg(test)]
93 | mod tests {
94 | use super::*;
95 | use parity_scale_codec::Encode;
96 |
97 | #[test]
98 | fn test_new_returns_none_if_zero() {
99 | assert_eq!(None, NonZeroU32::new(0));
100 | }
101 |
102 | #[test]
103 | fn test_new_returns_some_if_nonzero() {
104 | let n = 10;
105 | let expected = Some(NonZeroU32::new_unchecked(n));
106 |
107 | let actual = NonZeroU32::new(n);
108 | assert_eq!(expected, actual);
109 | assert_eq!(n, actual.unwrap().get());
110 | }
111 |
112 | #[test]
113 | fn test_decode_errors_if_zero_value() {
114 | let buf: Vec = 0u32.encode();
115 | let result = NonZeroU32::decode(&mut &buf[..]);
116 | assert!(result.is_err(), "expected error, got {:?}", result);
117 | }
118 |
119 | #[test]
120 | fn test_decode_succeeds_if_nonzero_value() {
121 | let buf: Vec = 1u32.encode();
122 |
123 | let result = NonZeroU32::decode(&mut &buf[..]);
124 | assert!(result.is_ok(), "unexpected error, got {:?}", result);
125 | assert_eq!(Ok(NonZeroU32::new_unchecked(1)), result);
126 | }
127 | }
128 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/tests.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Nimbus.
3 |
4 | // Nimbus is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Nimbus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Nimbus. If not, see .
16 |
17 | use super::*;
18 | use crate::mock::*;
19 | use crate::num::NonZeroU32;
20 |
21 | use frame_support::assert_ok;
22 | use frame_support::{traits::OnRuntimeUpgrade, weights::Weight};
23 | use sp_runtime::Percent;
24 |
25 | #[test]
26 | fn test_set_eligibility_works() {
27 | new_test_ext().execute_with(|| {
28 | let value = num::NonZeroU32::new_unchecked(34);
29 |
30 | assert_ok!(AuthorSlotFilter::set_eligible(
31 | RuntimeOrigin::root(),
32 | value.clone()
33 | ));
34 | assert_eq!(AuthorSlotFilter::eligible_count(), value)
35 | });
36 | }
37 |
38 | #[allow(deprecated)]
39 | #[test]
40 | fn test_migration_works_for_converting_existing_eligible_ratio_to_eligible_count() {
41 | new_test_ext().execute_with(|| {
42 | let input_eligible_ratio = Percent::from_percent(50);
43 | let total_author_count = mock::Authors::get().len();
44 | let eligible_author_count = input_eligible_ratio.mul_ceil(total_author_count) as u32;
45 | let expected_eligible_count = NonZeroU32::new_unchecked(eligible_author_count);
46 | let expected_weight =
47 | Weight::from_parts(TestDbWeight::get().write + TestDbWeight::get().read, 0);
48 |
49 | >::put(input_eligible_ratio);
50 |
51 | let actual_weight = migration::EligibleRatioToEligiblityCount::::on_runtime_upgrade();
52 | assert_eq!(expected_weight, actual_weight);
53 |
54 | let actual_eligible_ratio_after = AuthorSlotFilter::eligible_ratio();
55 | let actual_eligible_count = AuthorSlotFilter::eligible_count();
56 | assert_eq!(expected_eligible_count, actual_eligible_count);
57 | assert_eq!(input_eligible_ratio, actual_eligible_ratio_after);
58 | });
59 | }
60 |
61 | #[allow(deprecated)]
62 | #[test]
63 | fn test_migration_works_for_converting_existing_zero_eligible_ratio_to_default_eligible_count() {
64 | new_test_ext().execute_with(|| {
65 | let input_eligible_ratio = Percent::from_percent(0);
66 | let expected_eligible_count = EligibilityValue::default();
67 | let expected_weight =
68 | Weight::from_parts(TestDbWeight::get().write + TestDbWeight::get().read, 0);
69 |
70 | >::put(input_eligible_ratio);
71 |
72 | let actual_weight = migration::EligibleRatioToEligiblityCount::::on_runtime_upgrade();
73 | assert_eq!(expected_weight, actual_weight);
74 |
75 | let actual_eligible_ratio_after = AuthorSlotFilter::eligible_ratio();
76 | let actual_eligible_count = AuthorSlotFilter::eligible_count();
77 | assert_eq!(expected_eligible_count, actual_eligible_count);
78 | assert_eq!(input_eligible_ratio, actual_eligible_ratio_after);
79 | });
80 | }
81 |
82 | #[allow(deprecated)]
83 | #[test]
84 | fn test_migration_inserts_default_value_for_missing_eligible_ratio() {
85 | new_test_ext().execute_with(|| {
86 | let default_eligible_ratio = Percent::from_percent(50);
87 | let expected_default_eligible_count =
88 | NonZeroU32::new_unchecked(default_eligible_ratio.mul_ceil(Authors::get().len() as u32));
89 | let expected_weight =
90 | Weight::from_parts(TestDbWeight::get().write + TestDbWeight::get().read, 0);
91 |
92 | let actual_weight = migration::EligibleRatioToEligiblityCount::::on_runtime_upgrade();
93 | assert_eq!(expected_weight, actual_weight);
94 |
95 | let actual_eligible_count = AuthorSlotFilter::eligible_count();
96 | assert_eq!(expected_default_eligible_count, actual_eligible_count);
97 | });
98 | }
99 |
--------------------------------------------------------------------------------
/pallets/author-slot-filter/src/weights.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2019-2022 PureStake Inc.
2 | // This file is part of Moonbeam.
3 |
4 | // Moonbeam is free software: you can redistribute it and/or modify
5 | // it under the terms of the GNU General Public License as published by
6 | // the Free Software Foundation, either version 3 of the License, or
7 | // (at your option) any later version.
8 |
9 | // Moonbeam is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU General Public License for more details.
13 |
14 | // You should have received a copy of the GNU General Public License
15 | // along with Moonbeam. If not, see .
16 |
17 |
18 | //! Autogenerated weights for pallet_author_slot_filter
19 | //!
20 | //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
21 | //! DATE: 2023-05-02, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
22 | //! WORST CASE MAP SIZE: `1000000`
23 | //! HOSTNAME: `benchmarker`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
24 | //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
25 |
26 | // Executed Command:
27 | // ./target/release/moonbeam
28 | // benchmark
29 | // pallet
30 | // --execution=wasm
31 | // --wasm-execution=compiled
32 | // --pallet
33 | // *
34 | // --extrinsic
35 | // *
36 | // --steps
37 | // 50
38 | // --repeat
39 | // 20
40 | // --template=./benchmarking/frame-weight-template.hbs
41 | // --json-file
42 | // raw.json
43 | // --output
44 | // weights/
45 |
46 | #![cfg_attr(rustfmt, rustfmt_skip)]
47 | #![allow(unused_parens)]
48 | #![allow(unused_imports)]
49 |
50 | use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
51 | use sp_std::marker::PhantomData;
52 |
53 | /// Weight functions needed for pallet_author_slot_filter.
54 | pub trait WeightInfo {
55 | fn set_eligible() -> Weight;
56 | }
57 |
58 | /// Weights for pallet_author_slot_filter using the Substrate node and recommended hardware.
59 | pub struct SubstrateWeight(PhantomData