1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// This file is part of Soil.
// Copyright (C) Soil contributors.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later WITH Classpath-exception-2.0
pub use subsoil::inherents::{
CheckInherentsResult, InherentData, InherentIdentifier, IsFatalError, MakeFatalError,
};
/// A pallet that provides or verifies an inherent extrinsic will implement this trait.
///
/// The pallet may provide an inherent, verify an inherent, or both provide and verify.
///
/// Briefly, inherent extrinsics ("inherents") are extrinsics that are added to a block by the block
/// producer. See [`subsoil::inherents`] for more documentation on inherents.
pub trait ProvideInherent {
/// The call type of the pallet.
type Call;
/// The error returned by `check_inherent`.
type Error: codec::Encode + IsFatalError;
/// The inherent identifier used by this inherent.
const INHERENT_IDENTIFIER: self::InherentIdentifier;
/// Create an inherent out of the given `InherentData`.
///
/// NOTE: All checks necessary to ensure that the inherent is correct and that can be done in
/// the runtime should happen in the returned `Call`.
/// E.g. if this provides the timestamp, the call will check that the given timestamp is
/// increasing the old timestamp by more than a minimum and it will also check that the
/// timestamp hasn't already been set in the current block.
fn create_inherent(data: &InherentData) -> Option<Self::Call>;
/// Determines whether this inherent is required in this block.
///
/// - `Ok(None)` indicates that this inherent is not required in this block. The default
/// implementation returns this.
///
/// - `Ok(Some(e))` indicates that this inherent is required in this block. `construct_runtime!`
/// will call this function in its implementation of `fn check_extrinsics`.
/// If the inherent is not present, it will return `e`.
///
/// - `Err(_)` indicates that this function failed and further operations should be aborted.
///
/// NOTE: If the inherent is required then the runtime asserts that the block contains at least
/// one inherent for which:
/// * type is [`Self::Call`],
/// * [`Self::is_inherent`] returns true.
///
/// NOTE: This is currently only checked by block producers, not all full nodes.
fn is_inherent_required(_: &InherentData) -> Result<Option<Self::Error>, Self::Error> {
Ok(None)
}
/// Check whether the given inherent is valid. Checking the inherent is optional and can be
/// omitted by using the default implementation.
///
/// When checking an inherent, the first parameter represents the inherent that is actually
/// included in the block by its author. Whereas the second parameter represents the inherent
/// data that the verifying node calculates.
///
/// This is intended to allow for checks that cannot be done within the runtime such as, e.g.,
/// the timestamp.
///
/// # Warning
///
/// This check is not guaranteed to be run by all full nodes and cannot be relied upon for
/// ensuring that the block is correct.
fn check_inherent(_: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
Ok(())
}
/// Return whether the call is an inherent call.
///
/// NOTE: Signed extrinsics are not inherents, but a signed extrinsic with the given call
/// variant can be dispatched.
///
/// # Warning
///
/// In FRAME, inherents are enforced to be executed before other extrinsics. For this reason,
/// pallets with unsigned transactions **must ensure** that no unsigned transaction call
/// is an inherent call, when implementing `ValidateUnsigned::validate_unsigned`.
/// Otherwise block producers can produce invalid blocks by including them after non inherents.
fn is_inherent(call: &Self::Call) -> bool;
}