mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-09 20:11:09 +00:00
Remove uncles related code (#13216)
The code was added without any clear usage. The inherent for example is not benchmarked and not used.
This commit is contained in:
Bastian Köcher
Generated
-24
@@ -4772,7 +4772,6 @@ dependencies = [
|
||||
"sc-consensus-babe",
|
||||
"sc-consensus-epochs",
|
||||
"sc-consensus-slots",
|
||||
"sc-consensus-uncles",
|
||||
"sc-executor",
|
||||
"sc-finality-grandpa",
|
||||
"sc-keystore",
|
||||
@@ -4792,7 +4791,6 @@ dependencies = [
|
||||
"soketto",
|
||||
"sp-api",
|
||||
"sp-authority-discovery",
|
||||
"sp-authorship",
|
||||
"sp-blockchain",
|
||||
"sp-consensus",
|
||||
"sp-consensus-babe",
|
||||
@@ -5379,7 +5377,6 @@ dependencies = [
|
||||
"impl-trait-for-tuples",
|
||||
"parity-scale-codec",
|
||||
"scale-info",
|
||||
"sp-authorship",
|
||||
"sp-core",
|
||||
"sp-io",
|
||||
"sp-runtime",
|
||||
@@ -8299,16 +8296,6 @@ dependencies = [
|
||||
"substrate-test-runtime-client",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sc-consensus-uncles"
|
||||
version = "0.10.0-dev"
|
||||
dependencies = [
|
||||
"sc-client-api",
|
||||
"sp-authorship",
|
||||
"sp-runtime",
|
||||
"thiserror",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sc-executor"
|
||||
version = "0.10.0-dev"
|
||||
@@ -9714,17 +9701,6 @@ dependencies = [
|
||||
"sp-std",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sp-authorship"
|
||||
version = "4.0.0-dev"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"parity-scale-codec",
|
||||
"sp-inherents",
|
||||
"sp-runtime",
|
||||
"sp-std",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sp-beefy"
|
||||
version = "4.0.0-dev"
|
||||
|
||||
@@ -32,7 +32,6 @@ members = [
|
||||
"client/consensus/manual-seal",
|
||||
"client/consensus/pow",
|
||||
"client/consensus/slots",
|
||||
"client/consensus/uncles",
|
||||
"client/db",
|
||||
"client/executor",
|
||||
"client/executor/common",
|
||||
@@ -177,7 +176,6 @@ members = [
|
||||
"primitives/arithmetic",
|
||||
"primitives/arithmetic/fuzzer",
|
||||
"primitives/authority-discovery",
|
||||
"primitives/authorship",
|
||||
"primitives/beefy",
|
||||
"primitives/block-builder",
|
||||
"primitives/blockchain",
|
||||
|
||||
@@ -52,7 +52,6 @@ sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
|
||||
sp-core = { version = "7.0.0", path = "../../../primitives/core" }
|
||||
sp-runtime = { version = "7.0.0", path = "../../../primitives/runtime" }
|
||||
sp-timestamp = { version = "4.0.0-dev", path = "../../../primitives/timestamp" }
|
||||
sp-authorship = { version = "4.0.0-dev", path = "../../../primitives/authorship" }
|
||||
sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
|
||||
sp-keyring = { version = "7.0.0", path = "../../../primitives/keyring" }
|
||||
sp-keystore = { version = "0.13.0", path = "../../../primitives/keystore" }
|
||||
@@ -71,7 +70,6 @@ sc-network = { version = "0.10.0-dev", path = "../../../client/network" }
|
||||
sc-network-common = { version = "0.10.0-dev", path = "../../../client/network/common" }
|
||||
sc-consensus-slots = { version = "0.10.0-dev", path = "../../../client/consensus/slots" }
|
||||
sc-consensus-babe = { version = "0.10.0-dev", path = "../../../client/consensus/babe" }
|
||||
sc-consensus-uncles = { version = "0.10.0-dev", path = "../../../client/consensus/uncles" }
|
||||
grandpa = { version = "0.10.0-dev", package = "sc-finality-grandpa", path = "../../../client/finality-grandpa" }
|
||||
sc-rpc = { version = "4.0.0-dev", path = "../../../client/rpc" }
|
||||
sc-basic-authorship = { version = "0.10.0-dev", path = "../../../client/basic-authorship" }
|
||||
|
||||
@@ -222,10 +222,7 @@ pub fn new_partial(
|
||||
slot_duration,
|
||||
);
|
||||
|
||||
let uncles =
|
||||
sp_authorship::InherentDataProvider::<<Block as BlockT>::Header>::check_inherents();
|
||||
|
||||
Ok((slot, timestamp, uncles))
|
||||
Ok((slot, timestamp))
|
||||
},
|
||||
&task_manager.spawn_essential_handle(),
|
||||
config.prometheus_registry(),
|
||||
@@ -440,11 +437,6 @@ pub fn new_full_base(
|
||||
create_inherent_data_providers: move |parent, ()| {
|
||||
let client_clone = client_clone.clone();
|
||||
async move {
|
||||
let uncles = sc_consensus_uncles::create_uncles_inherent_data_provider(
|
||||
&*client_clone,
|
||||
parent,
|
||||
)?;
|
||||
|
||||
let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
|
||||
|
||||
let slot =
|
||||
@@ -459,7 +451,7 @@ pub fn new_full_base(
|
||||
&parent,
|
||||
)?;
|
||||
|
||||
Ok((slot, timestamp, uncles, storage_proof))
|
||||
Ok((slot, timestamp, storage_proof))
|
||||
}
|
||||
},
|
||||
force_authoring,
|
||||
|
||||
@@ -488,14 +488,8 @@ impl pallet_timestamp::Config for Runtime {
|
||||
type WeightInfo = pallet_timestamp::weights::SubstrateWeight<Runtime>;
|
||||
}
|
||||
|
||||
parameter_types! {
|
||||
pub const UncleGenerations: BlockNumber = 5;
|
||||
}
|
||||
|
||||
impl pallet_authorship::Config for Runtime {
|
||||
type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
|
||||
type UncleGenerations = UncleGenerations;
|
||||
type FilterUncle = ();
|
||||
type EventHandler = (Staking, ImOnline);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
[package]
|
||||
name = "sc-consensus-uncles"
|
||||
version = "0.10.0-dev"
|
||||
authors = ["Parity Technologies <admin@parity.io>"]
|
||||
description = "Generic uncle inclusion utilities for consensus"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
|
||||
homepage = "https://substrate.io"
|
||||
repository = "https://github.com/paritytech/substrate/"
|
||||
readme = "README.md"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
|
||||
[dependencies]
|
||||
thiserror = "1.0.30"
|
||||
sc-client-api = { version = "4.0.0-dev", path = "../../api" }
|
||||
sp-authorship = { version = "4.0.0-dev", path = "../../../primitives/authorship" }
|
||||
sp-runtime = { version = "7.0.0", path = "../../../primitives/runtime" }
|
||||
@@ -1,3 +0,0 @@
|
||||
Uncles functionality for Substrate.
|
||||
|
||||
License: GPL-3.0-or-later WITH Classpath-exception-2.0
|
||||
@@ -1,45 +0,0 @@
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Copyright (C) 2019-2022 Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
|
||||
|
||||
// This program 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.
|
||||
|
||||
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
//! Uncles functionality for Substrate.
|
||||
|
||||
use sc_client_api::ProvideUncles;
|
||||
use sp_runtime::{generic::BlockId, traits::Block as BlockT};
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum Error<B: BlockT> {
|
||||
#[error("Could not retrieve the block hash for block id: {0:?}")]
|
||||
NoHashForBlockId(BlockId<B>),
|
||||
}
|
||||
|
||||
/// Maximum uncles generations we may provide to the runtime.
|
||||
const MAX_UNCLE_GENERATIONS: u32 = 8;
|
||||
|
||||
/// Create a new [`sp_authorship::InherentDataProvider`] at the given block.
|
||||
pub fn create_uncles_inherent_data_provider<B, C>(
|
||||
client: &C,
|
||||
parent: B::Hash,
|
||||
) -> Result<sp_authorship::InherentDataProvider<B::Header>, sc_client_api::blockchain::Error>
|
||||
where
|
||||
B: BlockT,
|
||||
C: ProvideUncles<B>,
|
||||
{
|
||||
let uncles = client.uncles(parent, MAX_UNCLE_GENERATIONS.into())?;
|
||||
|
||||
Ok(sp_authorship::InherentDataProvider::new(uncles))
|
||||
}
|
||||
@@ -20,7 +20,6 @@ impl-trait-for-tuples = "0.2.2"
|
||||
scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
|
||||
frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
|
||||
frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
|
||||
sp-authorship = { version = "4.0.0-dev", default-features = false, path = "../../primitives/authorship" }
|
||||
sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
|
||||
sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
|
||||
|
||||
@@ -35,7 +34,6 @@ std = [
|
||||
"frame-support/std",
|
||||
"frame-system/std",
|
||||
"scale-info/std",
|
||||
"sp-authorship/std",
|
||||
"sp-runtime/std",
|
||||
"sp-std/std",
|
||||
]
|
||||
|
||||
@@ -17,36 +17,12 @@
|
||||
|
||||
//! Authorship tracking for FRAME runtimes.
|
||||
//!
|
||||
//! This tracks the current author of the block and recent uncles.
|
||||
//! This tracks the current author of the block.
|
||||
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
use codec::{Decode, Encode, MaxEncodedLen};
|
||||
use frame_support::{
|
||||
dispatch,
|
||||
traits::{Defensive, FindAuthor, Get, VerifySeal},
|
||||
BoundedSlice, BoundedVec,
|
||||
};
|
||||
use sp_authorship::{InherentError, UnclesInherentData, INHERENT_IDENTIFIER};
|
||||
use sp_runtime::traits::{Header as HeaderT, One, Saturating, UniqueSaturatedInto};
|
||||
use sp_std::{collections::btree_set::BTreeSet, prelude::*, result};
|
||||
|
||||
const MAX_UNCLES: usize = 10;
|
||||
|
||||
struct MaxUncleEntryItems<T>(core::marker::PhantomData<T>);
|
||||
impl<T: Config> Get<u32> for MaxUncleEntryItems<T> {
|
||||
fn get() -> u32 {
|
||||
// There can be at most `MAX_UNCLES` of `UncleEntryItem::Uncle` and
|
||||
// one `UncleEntryItem::InclusionHeight` per one `UncleGenerations`,
|
||||
// so this gives us `MAX_UNCLES + 1` entries per one generation.
|
||||
//
|
||||
// There can be one extra generation worth of uncles (e.g. even
|
||||
// if `UncleGenerations` is zero the pallet will still hold
|
||||
// one generation worth of uncles).
|
||||
let max_generations: u32 = T::UncleGenerations::get().unique_saturated_into();
|
||||
(MAX_UNCLES as u32 + 1) * (max_generations + 1)
|
||||
}
|
||||
}
|
||||
use frame_support::traits::FindAuthor;
|
||||
use sp_std::prelude::*;
|
||||
|
||||
pub use pallet::*;
|
||||
|
||||
@@ -56,87 +32,8 @@ pub use pallet::*;
|
||||
pub trait EventHandler<Author, BlockNumber> {
|
||||
/// Note that the given account ID is the author of the current block.
|
||||
fn note_author(author: Author);
|
||||
|
||||
/// Note that the given account ID authored the given uncle, and how many
|
||||
/// blocks older than the current block it is (age >= 0, so siblings are allowed)
|
||||
fn note_uncle(author: Author, age: BlockNumber);
|
||||
}
|
||||
|
||||
/// Additional filtering on uncles that pass preliminary ancestry checks.
|
||||
///
|
||||
/// This should do work such as checking seals
|
||||
pub trait FilterUncle<Header, Author> {
|
||||
/// An accumulator of data about uncles included.
|
||||
///
|
||||
/// In practice, this is used to validate uncles against others in the same block.
|
||||
type Accumulator: Default;
|
||||
|
||||
/// Do additional filtering on a seal-checked uncle block, with the accumulated
|
||||
/// filter.
|
||||
fn filter_uncle(
|
||||
header: &Header,
|
||||
acc: &mut Self::Accumulator,
|
||||
) -> Result<Option<Author>, &'static str>;
|
||||
}
|
||||
|
||||
impl<H, A> FilterUncle<H, A> for () {
|
||||
type Accumulator = ();
|
||||
fn filter_uncle(_: &H, _acc: &mut Self::Accumulator) -> Result<Option<A>, &'static str> {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// A filter on uncles which verifies seals and does no additional checks.
|
||||
/// This is well-suited to consensus modes such as PoW where the cost of
|
||||
/// equivocating is high.
|
||||
pub struct SealVerify<T>(sp_std::marker::PhantomData<T>);
|
||||
|
||||
impl<Header, Author, T: VerifySeal<Header, Author>> FilterUncle<Header, Author> for SealVerify<T> {
|
||||
type Accumulator = ();
|
||||
|
||||
fn filter_uncle(header: &Header, _acc: &mut ()) -> Result<Option<Author>, &'static str> {
|
||||
T::verify_seal(header)
|
||||
}
|
||||
}
|
||||
|
||||
/// A filter on uncles which verifies seals and ensures that there is only
|
||||
/// one uncle included per author per height.
|
||||
///
|
||||
/// This does O(n log n) work in the number of uncles included.
|
||||
pub struct OnePerAuthorPerHeight<T, N>(sp_std::marker::PhantomData<(T, N)>);
|
||||
|
||||
impl<Header, Author, T> FilterUncle<Header, Author> for OnePerAuthorPerHeight<T, Header::Number>
|
||||
where
|
||||
Header: HeaderT + PartialEq,
|
||||
Header::Number: Ord,
|
||||
Author: Clone + PartialEq + Ord,
|
||||
T: VerifySeal<Header, Author>,
|
||||
{
|
||||
type Accumulator = BTreeSet<(Header::Number, Author)>;
|
||||
|
||||
fn filter_uncle(
|
||||
header: &Header,
|
||||
acc: &mut Self::Accumulator,
|
||||
) -> Result<Option<Author>, &'static str> {
|
||||
let author = T::verify_seal(header)?;
|
||||
let number = header.number();
|
||||
|
||||
if let Some(ref author) = author {
|
||||
if !acc.insert((*number, author.clone())) {
|
||||
return Err("more than one uncle per number per author included")
|
||||
}
|
||||
}
|
||||
|
||||
Ok(author)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Encode, Decode, sp_runtime::RuntimeDebug, scale_info::TypeInfo, MaxEncodedLen)]
|
||||
#[cfg_attr(any(feature = "std", test), derive(PartialEq))]
|
||||
enum UncleEntryItem<BlockNumber, Hash, Author> {
|
||||
InclusionHeight(BlockNumber),
|
||||
Uncle(Hash, Option<Author>),
|
||||
}
|
||||
#[frame_support::pallet]
|
||||
pub mod pallet {
|
||||
use super::*;
|
||||
@@ -147,25 +44,6 @@ pub mod pallet {
|
||||
pub trait Config: frame_system::Config {
|
||||
/// Find the author of a block.
|
||||
type FindAuthor: FindAuthor<Self::AccountId>;
|
||||
/// The number of blocks back we should accept uncles.
|
||||
/// This means that we will deal with uncle-parents that are
|
||||
/// `UncleGenerations + 1` before `now`.
|
||||
#[pallet::constant]
|
||||
type UncleGenerations: Get<Self::BlockNumber>;
|
||||
/// A filter for uncles within a block. This is for implementing
|
||||
/// further constraints on what uncles can be included, other than their ancestry.
|
||||
///
|
||||
/// For PoW, as long as the seals are checked, there is no need to use anything
|
||||
/// but the `VerifySeal` implementation as the filter. This is because the cost of making
|
||||
/// many equivocating uncles is high.
|
||||
///
|
||||
/// For PoS, there is no such limitation, so a further constraint must be imposed
|
||||
/// beyond a seal check in order to prevent an arbitrary number of
|
||||
/// equivocating uncles from being included.
|
||||
///
|
||||
/// The `OnePerAuthorPerHeight` filter is good for many slot-based PoS
|
||||
/// engines.
|
||||
type FilterUncle: FilterUncle<Self::Header, Self::AccountId>;
|
||||
/// An event handler for authored blocks.
|
||||
type EventHandler: EventHandler<Self::AccountId, Self::BlockNumber>;
|
||||
}
|
||||
@@ -176,16 +54,7 @@ pub mod pallet {
|
||||
|
||||
#[pallet::hooks]
|
||||
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
|
||||
fn on_initialize(now: T::BlockNumber) -> Weight {
|
||||
let uncle_generations = T::UncleGenerations::get();
|
||||
// prune uncles that are older than the allowed number of generations.
|
||||
if uncle_generations <= now {
|
||||
let minimum_height = now - uncle_generations;
|
||||
Self::prune_old_uncles(minimum_height)
|
||||
}
|
||||
|
||||
<DidSetUncles<T>>::put(false);
|
||||
|
||||
fn on_initialize(_: T::BlockNumber) -> Weight {
|
||||
if let Some(author) = Self::author() {
|
||||
T::EventHandler::note_author(author);
|
||||
}
|
||||
@@ -196,125 +65,12 @@ pub mod pallet {
|
||||
fn on_finalize(_: T::BlockNumber) {
|
||||
// ensure we never go to trie with these values.
|
||||
<Author<T>>::kill();
|
||||
<DidSetUncles<T>>::kill();
|
||||
}
|
||||
}
|
||||
|
||||
#[pallet::storage]
|
||||
/// Uncles
|
||||
pub(super) type Uncles<T: Config> = StorageValue<
|
||||
_,
|
||||
BoundedVec<UncleEntryItem<T::BlockNumber, T::Hash, T::AccountId>, MaxUncleEntryItems<T>>,
|
||||
ValueQuery,
|
||||
>;
|
||||
|
||||
#[pallet::storage]
|
||||
/// Author of current block.
|
||||
pub(super) type Author<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
/// Whether uncles were already set in this block.
|
||||
pub(super) type DidSetUncles<T: Config> = StorageValue<_, bool, ValueQuery>;
|
||||
|
||||
#[pallet::error]
|
||||
pub enum Error<T> {
|
||||
/// The uncle parent not in the chain.
|
||||
InvalidUncleParent,
|
||||
/// Uncles already set in the block.
|
||||
UnclesAlreadySet,
|
||||
/// Too many uncles.
|
||||
TooManyUncles,
|
||||
/// The uncle is genesis.
|
||||
GenesisUncle,
|
||||
/// The uncle is too high in chain.
|
||||
TooHighUncle,
|
||||
/// The uncle is already included.
|
||||
UncleAlreadyIncluded,
|
||||
/// The uncle isn't recent enough to be included.
|
||||
OldUncle,
|
||||
}
|
||||
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {
|
||||
/// Provide a set of uncles.
|
||||
#[pallet::call_index(0)]
|
||||
#[pallet::weight((0, DispatchClass::Mandatory))]
|
||||
pub fn set_uncles(origin: OriginFor<T>, new_uncles: Vec<T::Header>) -> DispatchResult {
|
||||
ensure_none(origin)?;
|
||||
ensure!(new_uncles.len() <= MAX_UNCLES, Error::<T>::TooManyUncles);
|
||||
|
||||
if <DidSetUncles<T>>::get() {
|
||||
return Err(Error::<T>::UnclesAlreadySet.into())
|
||||
}
|
||||
<DidSetUncles<T>>::put(true);
|
||||
|
||||
Self::verify_and_import_uncles(new_uncles)
|
||||
}
|
||||
}
|
||||
|
||||
#[pallet::inherent]
|
||||
impl<T: Config> ProvideInherent for Pallet<T> {
|
||||
type Call = Call<T>;
|
||||
type Error = InherentError;
|
||||
const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
|
||||
|
||||
fn create_inherent(data: &InherentData) -> Option<Self::Call> {
|
||||
let uncles = data.uncles().unwrap_or_default();
|
||||
let mut new_uncles = Vec::new();
|
||||
|
||||
if !uncles.is_empty() {
|
||||
let prev_uncles = <Uncles<T>>::get();
|
||||
let mut existing_hashes: Vec<_> = prev_uncles
|
||||
.into_iter()
|
||||
.filter_map(|entry| match entry {
|
||||
UncleEntryItem::InclusionHeight(_) => None,
|
||||
UncleEntryItem::Uncle(h, _) => Some(h),
|
||||
})
|
||||
.collect();
|
||||
|
||||
let mut acc: <T::FilterUncle as FilterUncle<_, _>>::Accumulator =
|
||||
Default::default();
|
||||
|
||||
for uncle in uncles {
|
||||
match Self::verify_uncle(&uncle, &existing_hashes, &mut acc) {
|
||||
Ok(_) => {
|
||||
let hash = uncle.hash();
|
||||
new_uncles.push(uncle);
|
||||
existing_hashes.push(hash);
|
||||
|
||||
if new_uncles.len() == MAX_UNCLES {
|
||||
break
|
||||
}
|
||||
},
|
||||
Err(_) => {
|
||||
// skip this uncle
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if new_uncles.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(Call::set_uncles { new_uncles })
|
||||
}
|
||||
}
|
||||
|
||||
fn check_inherent(
|
||||
call: &Self::Call,
|
||||
_data: &InherentData,
|
||||
) -> result::Result<(), Self::Error> {
|
||||
match call {
|
||||
Call::set_uncles { ref new_uncles } if new_uncles.len() > MAX_UNCLES =>
|
||||
Err(InherentError::Uncles(Error::<T>::TooManyUncles.as_str().into())),
|
||||
_ => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
fn is_inherent(call: &Self::Call) -> bool {
|
||||
matches!(call, Call::set_uncles { .. })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> Pallet<T> {
|
||||
@@ -323,7 +79,7 @@ impl<T: Config> Pallet<T> {
|
||||
/// This is safe to invoke in `on_initialize` implementations, as well
|
||||
/// as afterwards.
|
||||
pub fn author() -> Option<T::AccountId> {
|
||||
// Check the memoized storage value.
|
||||
// Check the memorized storage value.
|
||||
if let Some(author) = <Author<T>>::get() {
|
||||
return Some(author)
|
||||
}
|
||||
@@ -335,113 +91,22 @@ impl<T: Config> Pallet<T> {
|
||||
a
|
||||
})
|
||||
}
|
||||
|
||||
fn verify_and_import_uncles(new_uncles: Vec<T::Header>) -> dispatch::DispatchResult {
|
||||
let now = <frame_system::Pallet<T>>::block_number();
|
||||
|
||||
let mut uncles = <Uncles<T>>::get();
|
||||
uncles
|
||||
.try_push(UncleEntryItem::InclusionHeight(now))
|
||||
.defensive_proof("the list of uncles accepted per generation is bounded, and the number of generations is bounded, so pushing a new element will always succeed")
|
||||
.map_err(|_| Error::<T>::TooManyUncles)?;
|
||||
|
||||
let mut acc: <T::FilterUncle as FilterUncle<_, _>>::Accumulator = Default::default();
|
||||
|
||||
for uncle in new_uncles {
|
||||
let prev_uncles = uncles.iter().filter_map(|entry| match entry {
|
||||
UncleEntryItem::InclusionHeight(_) => None,
|
||||
UncleEntryItem::Uncle(h, _) => Some(h),
|
||||
});
|
||||
let maybe_author = Self::verify_uncle(&uncle, prev_uncles, &mut acc)?;
|
||||
let hash = uncle.hash();
|
||||
|
||||
if let Some(author) = maybe_author.clone() {
|
||||
T::EventHandler::note_uncle(author, now - *uncle.number());
|
||||
}
|
||||
uncles.try_push(UncleEntryItem::Uncle(hash, maybe_author))
|
||||
.defensive_proof("the list of uncles accepted per generation is bounded, and the number of generations is bounded, so pushing a new element will always succeed")
|
||||
.map_err(|_| Error::<T>::TooManyUncles)?;
|
||||
}
|
||||
|
||||
<Uncles<T>>::put(&uncles);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn verify_uncle<'a, I: IntoIterator<Item = &'a T::Hash>>(
|
||||
uncle: &T::Header,
|
||||
existing_uncles: I,
|
||||
accumulator: &mut <T::FilterUncle as FilterUncle<T::Header, T::AccountId>>::Accumulator,
|
||||
) -> Result<Option<T::AccountId>, dispatch::DispatchError> {
|
||||
let now = <frame_system::Pallet<T>>::block_number();
|
||||
|
||||
let (minimum_height, maximum_height) = {
|
||||
let uncle_generations = T::UncleGenerations::get();
|
||||
let min = now.saturating_sub(uncle_generations);
|
||||
|
||||
(min, now)
|
||||
};
|
||||
|
||||
let hash = uncle.hash();
|
||||
|
||||
if uncle.number() < &One::one() {
|
||||
return Err(Error::<T>::GenesisUncle.into())
|
||||
}
|
||||
|
||||
if uncle.number() > &maximum_height {
|
||||
return Err(Error::<T>::TooHighUncle.into())
|
||||
}
|
||||
|
||||
{
|
||||
let parent_number = *uncle.number() - One::one();
|
||||
let parent_hash = <frame_system::Pallet<T>>::block_hash(&parent_number);
|
||||
if &parent_hash != uncle.parent_hash() {
|
||||
return Err(Error::<T>::InvalidUncleParent.into())
|
||||
}
|
||||
}
|
||||
|
||||
if uncle.number() < &minimum_height {
|
||||
return Err(Error::<T>::OldUncle.into())
|
||||
}
|
||||
|
||||
let duplicate = existing_uncles.into_iter().any(|h| *h == hash);
|
||||
let in_chain = <frame_system::Pallet<T>>::block_hash(uncle.number()) == hash;
|
||||
|
||||
if duplicate || in_chain {
|
||||
return Err(Error::<T>::UncleAlreadyIncluded.into())
|
||||
}
|
||||
|
||||
// check uncle validity.
|
||||
T::FilterUncle::filter_uncle(uncle, accumulator).map_err(Into::into)
|
||||
}
|
||||
|
||||
fn prune_old_uncles(minimum_height: T::BlockNumber) {
|
||||
let uncles = <Uncles<T>>::get();
|
||||
let prune_entries = uncles.iter().take_while(|item| match item {
|
||||
UncleEntryItem::Uncle(_, _) => true,
|
||||
UncleEntryItem::InclusionHeight(height) => height < &minimum_height,
|
||||
});
|
||||
let prune_index = prune_entries.count();
|
||||
let pruned_uncles =
|
||||
<BoundedSlice<'_, _, MaxUncleEntryItems<T>>>::try_from(&uncles[prune_index..])
|
||||
.expect("after pruning we can't end up with more uncles than we started with");
|
||||
|
||||
<Uncles<T>>::put(pruned_uncles);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate as pallet_authorship;
|
||||
use codec::{Decode, Encode};
|
||||
use frame_support::{
|
||||
traits::{ConstU32, ConstU64, OnFinalize, OnInitialize},
|
||||
traits::{ConstU32, ConstU64},
|
||||
ConsensusEngineId,
|
||||
};
|
||||
use sp_core::H256;
|
||||
use sp_runtime::{
|
||||
generic::DigestItem,
|
||||
testing::Header,
|
||||
traits::{BlakeTwo256, IdentityLookup},
|
||||
traits::{BlakeTwo256, Header as HeaderT, IdentityLookup},
|
||||
};
|
||||
|
||||
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
|
||||
@@ -454,7 +119,7 @@ mod tests {
|
||||
UncheckedExtrinsic = UncheckedExtrinsic,
|
||||
{
|
||||
System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
|
||||
Authorship: pallet_authorship::{Pallet, Call, Storage, Inherent},
|
||||
Authorship: pallet_authorship::{Pallet, Storage},
|
||||
}
|
||||
);
|
||||
|
||||
@@ -487,8 +152,6 @@ mod tests {
|
||||
|
||||
impl pallet::Config for Test {
|
||||
type FindAuthor = AuthorGiven;
|
||||
type UncleGenerations = ConstU64<5>;
|
||||
type FilterUncle = SealVerify<VerifyBlock>;
|
||||
type EventHandler = ();
|
||||
}
|
||||
|
||||
@@ -511,34 +174,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct VerifyBlock;
|
||||
|
||||
impl VerifySeal<Header, u64> for VerifyBlock {
|
||||
fn verify_seal(header: &Header) -> Result<Option<u64>, &'static str> {
|
||||
let pre_runtime_digests = header.digest.logs.iter().filter_map(|d| d.as_pre_runtime());
|
||||
let seals = header.digest.logs.iter().filter_map(|d| d.as_seal());
|
||||
|
||||
let author =
|
||||
AuthorGiven::find_author(pre_runtime_digests).ok_or_else(|| "no author")?;
|
||||
|
||||
for (id, mut seal) in seals {
|
||||
if id == TEST_ID {
|
||||
match u64::decode(&mut seal) {
|
||||
Err(_) => return Err("wrong seal"),
|
||||
Ok(a) => {
|
||||
if a != author {
|
||||
return Err("wrong author in seal")
|
||||
}
|
||||
break
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Some(author))
|
||||
}
|
||||
}
|
||||
|
||||
fn seal_header(mut header: Header, author: u64) -> Header {
|
||||
{
|
||||
let digest = header.digest_mut();
|
||||
@@ -558,196 +193,6 @@ mod tests {
|
||||
t.into()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prune_old_uncles_works() {
|
||||
use UncleEntryItem::*;
|
||||
new_test_ext().execute_with(|| {
|
||||
let hash = Default::default();
|
||||
let author = Default::default();
|
||||
let uncles = vec![
|
||||
InclusionHeight(1u64),
|
||||
Uncle(hash, Some(author)),
|
||||
Uncle(hash, None),
|
||||
Uncle(hash, None),
|
||||
InclusionHeight(2u64),
|
||||
Uncle(hash, None),
|
||||
InclusionHeight(3u64),
|
||||
Uncle(hash, None),
|
||||
];
|
||||
let uncles = BoundedVec::try_from(uncles).unwrap();
|
||||
|
||||
<Authorship as Store>::Uncles::put(uncles);
|
||||
Authorship::prune_old_uncles(3);
|
||||
|
||||
let uncles = <Authorship as Store>::Uncles::get();
|
||||
assert_eq!(uncles, vec![InclusionHeight(3u64), Uncle(hash, None)]);
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_bad_uncles() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let author_a = 69;
|
||||
|
||||
struct CanonChain {
|
||||
inner: Vec<Header>,
|
||||
}
|
||||
|
||||
impl CanonChain {
|
||||
fn best_hash(&self) -> H256 {
|
||||
self.inner.last().unwrap().hash()
|
||||
}
|
||||
|
||||
fn canon_hash(&self, index: usize) -> H256 {
|
||||
self.inner[index].hash()
|
||||
}
|
||||
|
||||
fn header(&self, index: usize) -> &Header {
|
||||
&self.inner[index]
|
||||
}
|
||||
|
||||
fn push(&mut self, header: Header) {
|
||||
self.inner.push(header)
|
||||
}
|
||||
}
|
||||
|
||||
let mut canon_chain = CanonChain {
|
||||
inner: vec![seal_header(
|
||||
create_header(0, Default::default(), Default::default()),
|
||||
999,
|
||||
)],
|
||||
};
|
||||
|
||||
let initialize_block = |number, hash: H256| {
|
||||
System::reset_events();
|
||||
System::initialize(&number, &hash, &Default::default())
|
||||
};
|
||||
|
||||
for number in 1..8 {
|
||||
initialize_block(number, canon_chain.best_hash());
|
||||
let header = seal_header(System::finalize(), author_a);
|
||||
canon_chain.push(header);
|
||||
}
|
||||
|
||||
// initialize so system context is set up correctly.
|
||||
initialize_block(8, canon_chain.best_hash());
|
||||
|
||||
// 2 of the same uncle at once
|
||||
{
|
||||
let uncle_a = seal_header(
|
||||
create_header(3, canon_chain.canon_hash(2), [1; 32].into()),
|
||||
author_a,
|
||||
);
|
||||
assert_eq!(
|
||||
Authorship::verify_and_import_uncles(vec![uncle_a.clone(), uncle_a.clone()]),
|
||||
Err(Error::<Test>::UncleAlreadyIncluded.into()),
|
||||
);
|
||||
}
|
||||
|
||||
// 2 of the same uncle at different times.
|
||||
{
|
||||
let uncle_a = seal_header(
|
||||
create_header(3, canon_chain.canon_hash(2), [1; 32].into()),
|
||||
author_a,
|
||||
);
|
||||
|
||||
assert!(Authorship::verify_and_import_uncles(vec![uncle_a.clone()]).is_ok());
|
||||
|
||||
assert_eq!(
|
||||
Authorship::verify_and_import_uncles(vec![uncle_a.clone()]),
|
||||
Err(Error::<Test>::UncleAlreadyIncluded.into()),
|
||||
);
|
||||
}
|
||||
|
||||
// same uncle as ancestor.
|
||||
{
|
||||
let uncle_clone = canon_chain.header(5).clone();
|
||||
|
||||
assert_eq!(
|
||||
Authorship::verify_and_import_uncles(vec![uncle_clone]),
|
||||
Err(Error::<Test>::UncleAlreadyIncluded.into()),
|
||||
);
|
||||
}
|
||||
|
||||
// uncle without valid seal.
|
||||
{
|
||||
let unsealed = create_header(3, canon_chain.canon_hash(2), [2; 32].into());
|
||||
assert_eq!(
|
||||
Authorship::verify_and_import_uncles(vec![unsealed]),
|
||||
Err("no author".into()),
|
||||
);
|
||||
}
|
||||
|
||||
// old uncles can't get in.
|
||||
{
|
||||
assert_eq!(System::block_number(), 8);
|
||||
|
||||
let gen_2 = seal_header(
|
||||
create_header(2, canon_chain.canon_hash(1), [3; 32].into()),
|
||||
author_a,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
Authorship::verify_and_import_uncles(vec![gen_2]),
|
||||
Err(Error::<Test>::OldUncle.into()),
|
||||
);
|
||||
}
|
||||
|
||||
// siblings are also allowed
|
||||
{
|
||||
let other_8 = seal_header(
|
||||
create_header(8, canon_chain.canon_hash(7), [1; 32].into()),
|
||||
author_a,
|
||||
);
|
||||
|
||||
assert!(Authorship::verify_and_import_uncles(vec![other_8]).is_ok());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn maximum_bound() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let mut max_item_count = 0;
|
||||
|
||||
let mut author_counter = 0;
|
||||
let mut current_depth = 1;
|
||||
let mut parent_hash: H256 = [1; 32].into();
|
||||
let mut uncles = vec![];
|
||||
|
||||
// We deliberately run this for more generations than the limit
|
||||
// so that we can get the `Uncles` to hit its cap.
|
||||
for _ in 0..<<Test as Config>::UncleGenerations as Get<u64>>::get() + 3 {
|
||||
let new_uncles: Vec<_> = (0..MAX_UNCLES)
|
||||
.map(|_| {
|
||||
System::reset_events();
|
||||
System::initialize(¤t_depth, &parent_hash, &Default::default());
|
||||
// Increment the author on every block to make sure the hash's always
|
||||
// different.
|
||||
author_counter += 1;
|
||||
seal_header(System::finalize(), author_counter)
|
||||
})
|
||||
.collect();
|
||||
|
||||
author_counter += 1;
|
||||
System::reset_events();
|
||||
System::initialize(¤t_depth, &parent_hash, &Default::default());
|
||||
Authorship::on_initialize(current_depth);
|
||||
Authorship::set_uncles(RuntimeOrigin::none(), uncles).unwrap();
|
||||
Authorship::on_finalize(current_depth);
|
||||
max_item_count =
|
||||
std::cmp::max(max_item_count, <Authorship as Store>::Uncles::get().len());
|
||||
|
||||
let new_parent = seal_header(System::finalize(), author_counter);
|
||||
parent_hash = new_parent.hash();
|
||||
uncles = new_uncles;
|
||||
current_depth += 1;
|
||||
}
|
||||
|
||||
assert_eq!(max_item_count, MaxUncleEntryItems::<Test>::get() as usize);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sets_author_lazily() {
|
||||
new_test_ext().execute_with(|| {
|
||||
@@ -762,33 +207,4 @@ mod tests {
|
||||
assert_eq!(Authorship::author(), Some(author));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_uncle_per_author_per_number() {
|
||||
type Filter = OnePerAuthorPerHeight<VerifyBlock, u64>;
|
||||
|
||||
let author_a = 42;
|
||||
let author_b = 43;
|
||||
|
||||
let mut acc: <Filter as FilterUncle<Header, u64>>::Accumulator = Default::default();
|
||||
let header_a1 = seal_header(create_header(1, Default::default(), [1; 32].into()), author_a);
|
||||
let header_b1 = seal_header(create_header(1, Default::default(), [1; 32].into()), author_b);
|
||||
|
||||
let header_a2_1 =
|
||||
seal_header(create_header(2, Default::default(), [1; 32].into()), author_a);
|
||||
let header_a2_2 =
|
||||
seal_header(create_header(2, Default::default(), [2; 32].into()), author_a);
|
||||
|
||||
let mut check_filter = move |uncle| Filter::filter_uncle(uncle, &mut acc);
|
||||
|
||||
// same height, different author is OK.
|
||||
assert_eq!(check_filter(&header_a1), Ok(Some(author_a)));
|
||||
assert_eq!(check_filter(&header_b1), Ok(Some(author_b)));
|
||||
|
||||
// same author, different height.
|
||||
assert_eq!(check_filter(&header_a2_1), Ok(Some(author_a)));
|
||||
|
||||
// same author, same height (author a, height 2)
|
||||
assert!(check_filter(&header_a2_2).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -52,15 +52,15 @@ frame_support::construct_runtime!(
|
||||
NodeBlock = Block,
|
||||
UncheckedExtrinsic = UncheckedExtrinsic,
|
||||
{
|
||||
System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
|
||||
Authorship: pallet_authorship::{Pallet, Call, Storage, Inherent},
|
||||
Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
|
||||
Historical: pallet_session_historical::{Pallet},
|
||||
Offences: pallet_offences::{Pallet, Storage, Event},
|
||||
Babe: pallet_babe::{Pallet, Call, Storage, Config, ValidateUnsigned},
|
||||
Staking: pallet_staking::{Pallet, Call, Storage, Config<T>, Event<T>},
|
||||
Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
|
||||
Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
|
||||
System: frame_system,
|
||||
Authorship: pallet_authorship,
|
||||
Balances: pallet_balances,
|
||||
Historical: pallet_session_historical,
|
||||
Offences: pallet_offences,
|
||||
Babe: pallet_babe,
|
||||
Staking: pallet_staking,
|
||||
Session: pallet_session,
|
||||
Timestamp: pallet_timestamp,
|
||||
}
|
||||
);
|
||||
|
||||
@@ -124,8 +124,6 @@ impl pallet_session::historical::Config for Test {
|
||||
|
||||
impl pallet_authorship::Config for Test {
|
||||
type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
|
||||
type UncleGenerations = ConstU64<0>;
|
||||
type FilterUncle = ();
|
||||
type EventHandler = ();
|
||||
}
|
||||
|
||||
|
||||
@@ -51,15 +51,15 @@ frame_support::construct_runtime!(
|
||||
NodeBlock = Block,
|
||||
UncheckedExtrinsic = UncheckedExtrinsic,
|
||||
{
|
||||
System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
|
||||
Authorship: pallet_authorship::{Pallet, Call, Storage, Inherent},
|
||||
Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
|
||||
Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
|
||||
Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
|
||||
Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
|
||||
Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event, ValidateUnsigned},
|
||||
Offences: pallet_offences::{Pallet, Storage, Event},
|
||||
Historical: pallet_session_historical::{Pallet},
|
||||
System: frame_system,
|
||||
Authorship: pallet_authorship,
|
||||
Timestamp: pallet_timestamp,
|
||||
Balances: pallet_balances,
|
||||
Staking: pallet_staking,
|
||||
Session: pallet_session,
|
||||
Grandpa: pallet_grandpa,
|
||||
Offences: pallet_offences,
|
||||
Historical: pallet_session_historical,
|
||||
}
|
||||
);
|
||||
|
||||
@@ -129,8 +129,6 @@ impl pallet_session::historical::Config for Test {
|
||||
|
||||
impl pallet_authorship::Config for Test {
|
||||
type FindAuthor = ();
|
||||
type UncleGenerations = ConstU64<0>;
|
||||
type FilterUncle = ();
|
||||
type EventHandler = ();
|
||||
}
|
||||
|
||||
|
||||
@@ -607,10 +607,6 @@ impl<T: Config + pallet_authorship::Config>
|
||||
fn note_author(author: ValidatorId<T>) {
|
||||
Self::note_authorship(author);
|
||||
}
|
||||
|
||||
fn note_uncle(author: ValidatorId<T>, _age: T::BlockNumber) {
|
||||
Self::note_authorship(author);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> Pallet<T> {
|
||||
|
||||
@@ -169,8 +169,6 @@ impl pallet_session::historical::Config for Runtime {
|
||||
|
||||
impl pallet_authorship::Config for Runtime {
|
||||
type FindAuthor = ();
|
||||
type UncleGenerations = ConstU64<5>;
|
||||
type FilterUncle = ();
|
||||
type EventHandler = ImOnline;
|
||||
}
|
||||
|
||||
|
||||
@@ -308,11 +308,10 @@ fn should_mark_online_validator_when_block_is_authored() {
|
||||
|
||||
// when
|
||||
ImOnline::note_author(1);
|
||||
ImOnline::note_uncle(2, 0);
|
||||
|
||||
// then
|
||||
assert!(ImOnline::is_online(0));
|
||||
assert!(ImOnline::is_online(1));
|
||||
assert!(!ImOnline::is_online(1));
|
||||
assert!(!ImOnline::is_online(2));
|
||||
});
|
||||
}
|
||||
@@ -338,7 +337,7 @@ fn should_not_send_a_report_if_already_online() {
|
||||
assert_eq!(Session::current_index(), 2);
|
||||
assert_eq!(Session::validators(), vec![1, 2, 3]);
|
||||
ImOnline::note_author(2);
|
||||
ImOnline::note_uncle(3, 0);
|
||||
ImOnline::note_author(3);
|
||||
|
||||
// when
|
||||
UintAuthorityId::set_all_keys(vec![1, 2, 3]);
|
||||
|
||||
@@ -91,14 +91,14 @@ frame_support::construct_runtime!(
|
||||
NodeBlock = Block,
|
||||
UncheckedExtrinsic = UncheckedExtrinsic,
|
||||
{
|
||||
System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
|
||||
Authorship: pallet_authorship::{Pallet, Call, Storage, Inherent},
|
||||
Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
|
||||
Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
|
||||
Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
|
||||
Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
|
||||
Historical: pallet_session::historical::{Pallet, Storage},
|
||||
VoterBagsList: pallet_bags_list::<Instance1>::{Pallet, Call, Storage, Event<T>},
|
||||
System: frame_system,
|
||||
Authorship: pallet_authorship,
|
||||
Timestamp: pallet_timestamp,
|
||||
Balances: pallet_balances,
|
||||
Staking: pallet_staking,
|
||||
Session: pallet_session,
|
||||
Historical: pallet_session::historical,
|
||||
VoterBagsList: pallet_bags_list::<Instance1>,
|
||||
}
|
||||
);
|
||||
|
||||
@@ -182,8 +182,6 @@ impl pallet_session::historical::Config for Test {
|
||||
}
|
||||
impl pallet_authorship::Config for Test {
|
||||
type FindAuthor = Author11;
|
||||
type UncleGenerations = ConstU64<0>;
|
||||
type FilterUncle = ();
|
||||
type EventHandler = Pallet<Test>;
|
||||
}
|
||||
|
||||
|
||||
@@ -1217,8 +1217,6 @@ impl<T: Config> historical::SessionManager<T::AccountId, Exposure<T::AccountId,
|
||||
|
||||
/// Add reward points to block authors:
|
||||
/// * 20 points to the block producer for producing a (non-uncle) block in the relay chain,
|
||||
/// * 2 points to the block producer for each reference to a previously unreferenced uncle, and
|
||||
/// * 1 point to the producer of each referenced uncle block.
|
||||
impl<T> pallet_authorship::EventHandler<T::AccountId, T::BlockNumber> for Pallet<T>
|
||||
where
|
||||
T: Config + pallet_authorship::Config + pallet_session::Config,
|
||||
@@ -1226,14 +1224,6 @@ where
|
||||
fn note_author(author: T::AccountId) {
|
||||
Self::reward_by_ids(vec![(author, 20)])
|
||||
}
|
||||
fn note_uncle(uncle_author: T::AccountId, _age: T::BlockNumber) {
|
||||
// defensive-only: block author must exist.
|
||||
if let Some(block_author) = <pallet_authorship::Pallet<T>>::author() {
|
||||
Self::reward_by_ids(vec![(block_author, 2), (uncle_author, 1)])
|
||||
} else {
|
||||
crate::log!(warn, "block author not set, this should never happen");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// This is intended to be used with `FilterHistoricalOffences`.
|
||||
|
||||
@@ -2237,9 +2237,7 @@ fn reward_from_authorship_event_handler_works() {
|
||||
assert_eq!(<pallet_authorship::Pallet<Test>>::author(), Some(11));
|
||||
|
||||
Pallet::<Test>::note_author(11);
|
||||
Pallet::<Test>::note_uncle(21, 1);
|
||||
// Rewarding the same two times works.
|
||||
Pallet::<Test>::note_uncle(11, 1);
|
||||
Pallet::<Test>::note_author(11);
|
||||
|
||||
// Not mandatory but must be coherent with rewards
|
||||
assert_eq_uvec!(Session::validators(), vec![11, 21]);
|
||||
@@ -2248,10 +2246,7 @@ fn reward_from_authorship_event_handler_works() {
|
||||
// 11 is rewarded as a block producer and uncle referencer and uncle producer
|
||||
assert_eq!(
|
||||
ErasRewardPoints::<Test>::get(active_era()),
|
||||
EraRewardPoints {
|
||||
individual: vec![(11, 20 + 2 * 2 + 1), (21, 1)].into_iter().collect(),
|
||||
total: 26,
|
||||
},
|
||||
EraRewardPoints { individual: vec![(11, 20 * 2)].into_iter().collect(), total: 40 },
|
||||
);
|
||||
})
|
||||
}
|
||||
|
||||
@@ -45,12 +45,12 @@ frame_support::construct_runtime!(
|
||||
NodeBlock = Block,
|
||||
UncheckedExtrinsic = UncheckedExtrinsic,
|
||||
{
|
||||
System: system::{Pallet, Call, Config, Storage, Event<T>},
|
||||
Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
|
||||
TransactionPayment: pallet_transaction_payment::{Pallet, Storage, Event<T>},
|
||||
Assets: pallet_assets::{Pallet, Call, Storage, Event<T>},
|
||||
Authorship: pallet_authorship::{Pallet, Call, Storage},
|
||||
AssetTxPayment: pallet_asset_tx_payment::{Pallet, Event<T>},
|
||||
System: system,
|
||||
Balances: pallet_balances,
|
||||
TransactionPayment: pallet_transaction_payment,
|
||||
Assets: pallet_assets,
|
||||
Authorship: pallet_authorship,
|
||||
AssetTxPayment: pallet_asset_tx_payment,
|
||||
}
|
||||
);
|
||||
|
||||
@@ -187,8 +187,6 @@ impl FindAuthor<AccountId> for HardcodedAuthor {
|
||||
|
||||
impl pallet_authorship::Config for Runtime {
|
||||
type FindAuthor = HardcodedAuthor;
|
||||
type UncleGenerations = ();
|
||||
type FilterUncle = ();
|
||||
type EventHandler = ();
|
||||
}
|
||||
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
[package]
|
||||
name = "sp-authorship"
|
||||
version = "4.0.0-dev"
|
||||
authors = ["Parity Technologies <admin@parity.io>"]
|
||||
description = "Authorship primitives"
|
||||
edition = "2021"
|
||||
license = "Apache-2.0"
|
||||
homepage = "https://substrate.io"
|
||||
repository = "https://github.com/paritytech/substrate/"
|
||||
readme = "README.md"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
|
||||
[dependencies]
|
||||
async-trait = { version = "0.1.57", optional = true }
|
||||
codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
|
||||
sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../inherents" }
|
||||
sp-runtime = { version = "7.0.0", default-features = false, path = "../runtime" }
|
||||
sp-std = { version = "5.0.0", default-features = false, path = "../std" }
|
||||
|
||||
[features]
|
||||
default = [ "std" ]
|
||||
std = [
|
||||
"async-trait",
|
||||
"codec/std",
|
||||
"sp-inherents/std",
|
||||
"sp-runtime/std",
|
||||
"sp-std/std",
|
||||
]
|
||||
@@ -1,3 +0,0 @@
|
||||
Authorship Primitives
|
||||
|
||||
License: Apache-2.0
|
||||
@@ -1,101 +0,0 @@
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Copyright (C) 2019-2022 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.
|
||||
|
||||
//! Authorship Primitives
|
||||
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
use sp_std::{prelude::*, result::Result};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use codec::Decode;
|
||||
use codec::Encode;
|
||||
use sp_inherents::{Error, InherentData, InherentIdentifier, IsFatalError};
|
||||
use sp_runtime::{traits::Header as HeaderT, RuntimeString};
|
||||
|
||||
/// The identifier for the `uncles` inherent.
|
||||
pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"uncles00";
|
||||
|
||||
/// Errors that can occur while checking the authorship inherent.
|
||||
#[derive(Encode, sp_runtime::RuntimeDebug)]
|
||||
#[cfg_attr(feature = "std", derive(Decode))]
|
||||
pub enum InherentError {
|
||||
Uncles(RuntimeString),
|
||||
}
|
||||
|
||||
impl IsFatalError for InherentError {
|
||||
fn is_fatal_error(&self) -> bool {
|
||||
match self {
|
||||
InherentError::Uncles(_) => true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Auxiliary trait to extract uncles inherent data.
|
||||
pub trait UnclesInherentData<H> {
|
||||
/// Get uncles.
|
||||
fn uncles(&self) -> Result<Vec<H>, Error>;
|
||||
}
|
||||
|
||||
impl<H: HeaderT> UnclesInherentData<H> for InherentData {
|
||||
fn uncles(&self) -> Result<Vec<H>, Error> {
|
||||
Ok(self.get_data(&INHERENT_IDENTIFIER)?.unwrap_or_default())
|
||||
}
|
||||
}
|
||||
|
||||
/// Provider for inherent data.
|
||||
#[cfg(feature = "std")]
|
||||
pub struct InherentDataProvider<H> {
|
||||
uncles: Vec<H>,
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl<H> InherentDataProvider<H> {
|
||||
/// Create a new inherent data provider with the given `uncles`.
|
||||
pub fn new(uncles: Vec<H>) -> Self {
|
||||
InherentDataProvider { uncles }
|
||||
}
|
||||
|
||||
/// Create a new instance that is usable for checking inherents.
|
||||
///
|
||||
/// This will always return an empty vec of uncles.
|
||||
pub fn check_inherents() -> Self {
|
||||
Self { uncles: Vec::new() }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
#[async_trait::async_trait]
|
||||
impl<H: HeaderT> sp_inherents::InherentDataProvider for InherentDataProvider<H> {
|
||||
async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error> {
|
||||
inherent_data.put_data(INHERENT_IDENTIFIER, &self.uncles)
|
||||
}
|
||||
|
||||
async fn try_handle_error(
|
||||
&self,
|
||||
identifier: &InherentIdentifier,
|
||||
mut error: &[u8],
|
||||
) -> Option<Result<(), Error>> {
|
||||
if *identifier != INHERENT_IDENTIFIER {
|
||||
return None
|
||||
}
|
||||
|
||||
let error = InherentError::decode(&mut error).ok()?;
|
||||
|
||||
Some(Err(Error::Application(Box::from(format!("{:?}", error)))))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user