Type Alias sp_runtime::Justification

source ·
pub type Justification = (ConsensusEngineId, EncodedJustification);
Expand description

An abstraction over justification for a block’s validity under a consensus algorithm.

Essentially a finality proof. The exact formulation will vary between consensus algorithms. In the case where there are multiple valid proofs, inclusion within the block itself would allow swapping justifications to change the block’s hash (and thus fork the chain). Sending a Justification alongside a block instead bypasses this problem.

Each justification is provided as an encoded blob, and is tagged with an ID to identify the consensus engine that generated the proof (we might have multiple justifications from different engines for the same block).

Trait Implementations§

source§

impl<S, T> Bounded for (S, T)where S: Bounded, T: Bounded,

source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)where T0: Deserialize<'de>, T1: Deserialize<'de>,

source§

fn deserialize<D>( deserializer: D ) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl<A: Clone, B, TupleElement0: MaybeConvert<A, B>, TupleElement1: MaybeConvert<A, B>> MaybeConvert<A, B> for (TupleElement0, TupleElement1)

source§

fn maybe_convert(a: A) -> Option<B>

Attempt to make conversion.
source§

impl<A: Clone, B: Clone, TupleElement0: MaybeConvertBack<A, B>, TupleElement1: MaybeConvertBack<A, B>> MaybeConvertBack<A, B> for (TupleElement0, TupleElement1)

source§

fn maybe_convert_back(b: B) -> Option<A>

Attempt to make conversion back.
source§

impl<A, B, TupleElement0: MaybeEquivalence<A, B>, TupleElement1: MaybeEquivalence<A, B>> MaybeEquivalence<A, B> for (TupleElement0, TupleElement1)

source§

fn convert(a: &A) -> Option<B>

Attempt to convert reference of A into value of B, returning None if not possible.
source§

fn convert_back(b: &B) -> Option<A>

Attempt to convert reference of B into value of A, returning None if not possible.
source§

impl<TupleElement0: Printable, TupleElement1: Printable> Printable for (TupleElement0, TupleElement1)

source§

fn print(&self)

Print the object.
source§

impl<T0, T1> Serialize for (T0, T1)where T0: Serialize, T1: Serialize,

source§

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl<AccountId, Call: Dispatchable, TupleElement0, TupleElement1> SignedExtension for (TupleElement0, TupleElement1)where TupleElement0: SignedExtension<AccountId = AccountId, Call = Call> + SignedExtension, TupleElement1: SignedExtension<AccountId = AccountId, Call = Call> + SignedExtension,

§

type AccountId = AccountId

The type which encodes the sender identity.
§

type Call = Call

The type which encodes the call to be dispatched.
source§

const IDENTIFIER: &'static str = "You should call `identifier()`!"

Unique identifier of this signed extension. Read more
§

type AdditionalSigned = (<TupleElement0 as SignedExtension>::AdditionalSigned, <TupleElement1 as SignedExtension>::AdditionalSigned)

Any additional data that will go into the signed payload. This may be created dynamically from the transaction using the additional_signed function.
§

type Pre = (<TupleElement0 as SignedExtension>::Pre, <TupleElement1 as SignedExtension>::Pre)

The type that encodes information that can be passed from pre_dispatch to post-dispatch.
source§

fn additional_signed( &self ) -> Result<Self::AdditionalSigned, TransactionValidityError>

Construct any additional data that should be in the signed payload of the transaction. Can also perform any pre-signature-verification checks and return an error if needed.
source§

fn validate( &self, who: &Self::AccountId, call: &Self::Call, info: &DispatchInfoOf<Self::Call>, len: usize ) -> TransactionValidity

Validate a signed transaction for the transaction queue. Read more
source§

fn pre_dispatch( self, who: &Self::AccountId, call: &Self::Call, info: &DispatchInfoOf<Self::Call>, len: usize ) -> Result<Self::Pre, TransactionValidityError>

Do any pre-flight stuff for a signed transaction. Read more
source§

fn validate_unsigned( call: &Self::Call, info: &DispatchInfoOf<Self::Call>, len: usize ) -> TransactionValidity

Validate an unsigned transaction for the transaction queue. Read more
source§

fn pre_dispatch_unsigned( call: &Self::Call, info: &DispatchInfoOf<Self::Call>, len: usize ) -> Result<(), TransactionValidityError>

Do any pre-flight stuff for a unsigned transaction. Read more
source§

fn post_dispatch( pre: Option<Self::Pre>, info: &DispatchInfoOf<Self::Call>, post_info: &PostDispatchInfoOf<Self::Call>, len: usize, result: &DispatchResult ) -> Result<(), TransactionValidityError>

Do any post-flight stuff for an extrinsic. Read more
source§

fn metadata() -> Vec<SignedExtensionMetadata>

Returns the metadata for this signed extension. Read more
source§

impl<A, B> StaticLookup for (A, B)where A: StaticLookup, B: StaticLookup<Source = A::Source, Target = A::Target>,

Perform a StaticLookup where there are multiple lookup sources of the same type.

§

type Source = <A as StaticLookup>::Source

Type to lookup from.
§

type Target = <A as StaticLookup>::Target

Type to lookup into.
source§

fn lookup(x: Self::Source) -> Result<Self::Target, LookupError>

Attempt a lookup.
source§

fn unlookup(x: Self::Target) -> Self::Source

Convert from Target back to Source.
source§

impl<A, B, TupleElement0: TryConvert<A, B>, TupleElement1: TryConvert<A, B>> TryConvert<A, B> for (TupleElement0, TupleElement1)

source§

fn try_convert(a: A) -> Result<B, A>

Attempt to make conversion. If returning Result::Err, the inner must always be a.
source§

impl<A, B, TupleElement0: TryConvertBack<A, B>, TupleElement1: TryConvertBack<A, B>> TryConvertBack<A, B> for (TupleElement0, TupleElement1)

source§

fn try_convert_back(b: B) -> Result<A, B>

Attempt to make conversion back. If returning Result::Err, the inner must always be b.
§

impl<T, F, A1, R> IntoFunc<T, (A1,), R> for Fwhere F: Fn(A1) -> R + Send + Sync + 'static, A1: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, R> IntoFunc<T, (A1, A2), R> for Fwhere F: Fn(A1, A2) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, R> IntoFunc<T, (A1, A2, A3), R> for Fwhere F: Fn(A1, A2, A3) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, R> IntoFunc<T, (A1, A2, A3, A4), R> for Fwhere F: Fn(A1, A2, A3, A4) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, R> IntoFunc<T, (A1, A2, A3, A4, A5), R> for Fwhere F: Fn(A1, A2, A3, A4, A5) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, A14: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, A14: WasmTy, A15: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R> IntoFunc<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), R> for Fwhere F: Fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, A14: WasmTy, A15: WasmTy, A16: WasmTy, R: WasmRet,

§

impl<T, F, R> IntoFunc<T, (Caller<'_, T>,), R> for Fwhere F: Fn(Caller<'_, T>) -> R + Send + Sync + 'static, R: WasmRet,

§

impl<T, F, A1, R> IntoFunc<T, (Caller<'_, T>, A1), R> for Fwhere F: Fn(Caller<'_, T>, A1) -> R + Send + Sync + 'static, A1: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, R> IntoFunc<T, (Caller<'_, T>, A1, A2), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, A14: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, A14: WasmTy, A15: WasmTy, R: WasmRet,

§

impl<T, F, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R> IntoFunc<T, (Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), R> for Fwhere F: Fn(Caller<'_, T>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> R + Send + Sync + 'static, A1: WasmTy, A2: WasmTy, A3: WasmTy, A4: WasmTy, A5: WasmTy, A6: WasmTy, A7: WasmTy, A8: WasmTy, A9: WasmTy, A10: WasmTy, A11: WasmTy, A12: WasmTy, A13: WasmTy, A14: WasmTy, A15: WasmTy, A16: WasmTy, R: WasmRet,