Trait frame_support::pallet_prelude::Decode[−]

pub trait Decode {
    fn decode<I>(input: &mut I) -> Result<Self, Error>
    where
        I: Input;

    fn skip<I>(input: &mut I) -> Result<(), Error>
    where
        I: Input,
    { ... }
    fn encoded_fixed_size() -> Option<usize> { ... }
}

Expand description

Trait that allows zero-copy read of value-references from slices in LE format.

Required methods

fn decode<I>(input: &mut I) -> Result<Self, Error> where
    I: Input,

Attempt to deserialise the value from input.

Provided methods

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input,

Attempt to skip the encoded value from input.

The default implementation of this function is just calling Decode::decode. When possible, an implementation should provided a specialized implementation.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

If it returns Some(size) then all possible values of this type have the given size (in bytes) when encoded.

NOTE: A type with a fixed encoded size may return None.

Implementations on Foreign Types

[src]

impl Decode for WasmMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for WasmValuesSet

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValuesSet, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for WasmFields

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmFields, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for WasmLevel

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmLevel, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for WasmFieldName

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmFieldName, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for WasmEntryAttributes

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmEntryAttributes, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for WasmValue

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValue, Error> where
    __CodecInputEdqy: Input,

impl<T> Decode for LinkedList<T> where
    T: Decode,

pub fn decode<I>(input: &mut I) -> Result<LinkedList<T>, Error> where
    I: Input,

impl Decode for i64

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i64, Error> where
    I: Input,

impl<K, V> Decode for BTreeMap<K, V> where
    K: Decode + Ord,
    V: Decode,

pub fn decode<I>(input: &mut I) -> Result<BTreeMap<K, V>, Error> where
    I: Input,

impl<F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    G0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for u32

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u32, Error> where
    I: Input,

impl Decode for Compact<u8>

pub fn decode<I>(input: &mut I) -> Result<Compact<u8>, Error> where
    I: Input,

impl<N0, O0, P0, Q0, R0> Decode for (N0, O0, P0, Q0, R0) where
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(input: &mut INPUT) -> Result<(N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for u64

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u64, Error> where
    I: Input,

impl Decode for OptionBool

pub fn decode<I>(input: &mut I) -> Result<OptionBool, Error> where
    I: Input,

impl<L0, M0, N0, O0, P0, Q0, R0> Decode for (L0, M0, N0, O0, P0, Q0, R0) where
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl<T> Decode for BTreeSet<T> where
    T: Decode + Ord,

pub fn decode<I>(input: &mut I) -> Result<BTreeSet<T>, Error> where
    I: Input,

impl<A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    B0: Decode,
    G0: Decode,
    A0: Decode,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl<T> Decode for RangeInclusive<T> where
    T: Decode,

pub fn decode<I>(input: &mut I) -> Result<RangeInclusive<T>, Error> where
    I: Input,

impl Decode for Compact<u32>

pub fn decode<I>(input: &mut I) -> Result<Compact<u32>, Error> where
    I: Input,

impl Decode for NonZeroI32

pub fn decode<I>(input: &mut I) -> Result<NonZeroI32, Error> where
    I: Input,

impl<Q0, R0> Decode for (Q0, R0) where
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(input: &mut INPUT) -> Result<(Q0, R0), Error> where
    INPUT: Input,

impl<T> Decode for Compact<T> where
    T: CompactAs,
    Compact<<T as CompactAs>::As>: Decode,

pub fn decode<I>(input: &mut I) -> Result<Compact<T>, Error> where
    I: Input,

impl<K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (K0, L0, M0, N0, O0, P0, Q0, R0) where
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for i8

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i8, Error> where
    I: Input,

impl<G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    G0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for Compact<()>

pub fn decode<I>(_input: &mut I) -> Result<Compact<()>, Error> where
    I: Input,

impl<R0> Decode for (R0,) where
    R0: Decode,

pub fn decode<I>(input: &mut I) -> Result<(R0,), Error> where
    I: Input,

impl<P0, Q0, R0> Decode for (P0, Q0, R0) where
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(input: &mut INPUT) -> Result<(P0, Q0, R0), Error> where
    INPUT: Input,

impl<M0, N0, O0, P0, Q0, R0> Decode for (M0, N0, O0, P0, Q0, R0) where
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for u128

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u128, Error> where
    I: Input,

impl Decode for Duration

pub fn decode<I>(input: &mut I) -> Result<Duration, Error> where
    I: Input,

impl Decode for String

pub fn decode<I>(input: &mut I) -> Result<String, Error> where
    I: Input,

impl Decode for NonZeroU64

pub fn decode<I>(input: &mut I) -> Result<NonZeroU64, Error> where
    I: Input,

impl<I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl<C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    G0: Decode,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for i32

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i32, Error> where
    I: Input,

impl Decode for u8

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u8, Error> where
    I: Input,

impl<T> Decode for Range<T> where
    T: Decode,

pub fn decode<I>(input: &mut I) -> Result<Range<T>, Error> where
    I: Input,

impl Decode for Compact<u128>

pub fn decode<I>(input: &mut I) -> Result<Compact<u128>, Error> where
    I: Input,

impl Decode for NonZeroI64

pub fn decode<I>(input: &mut I) -> Result<NonZeroI64, Error> where
    I: Input,

impl Decode for NonZeroU16

pub fn decode<I>(input: &mut I) -> Result<NonZeroU16, Error> where
    I: Input,

impl<E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    G0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for NonZeroI8

pub fn decode<I>(input: &mut I) -> Result<NonZeroI8, Error> where
    I: Input,

impl<T> Decode for BinaryHeap<T> where
    T: Decode + Ord,

pub fn decode<I>(input: &mut I) -> Result<BinaryHeap<T>, Error> where
    I: Input,

impl Decode for NonZeroU128

pub fn decode<I>(input: &mut I) -> Result<NonZeroU128, Error> where
    I: Input,

impl Decode for i16

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i16, Error> where
    I: Input,

impl Decode for NonZeroI16

pub fn decode<I>(input: &mut I) -> Result<NonZeroI16, Error> where
    I: Input,

impl Decode for bool

pub fn decode<I>(input: &mut I) -> Result<bool, Error> where
    I: Input,

impl Decode for NonZeroU8

pub fn decode<I>(input: &mut I) -> Result<NonZeroU8, Error> where
    I: Input,

impl<'a, T> Decode for Cow<'a, T> where
    T: ToOwned + ?Sized,
    <T as ToOwned>::Owned: Decode,

pub fn decode<I>(input: &mut I) -> Result<Cow<'a, T>, Error> where
    I: Input,

impl Decode for Compact<u16>

pub fn decode<I>(input: &mut I) -> Result<Compact<u16>, Error> where
    I: Input,

impl<B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    B0: Decode,
    G0: Decode,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for i128

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i128, Error> where
    I: Input,

impl<H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for Compact<u64>

pub fn decode<I>(input: &mut I) -> Result<Compact<u64>, Error> where
    I: Input,

impl<O0, P0, Q0, R0> Decode for (O0, P0, Q0, R0) where
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(input: &mut INPUT) -> Result<(O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for NonZeroI128

pub fn decode<I>(input: &mut I) -> Result<NonZeroI128, Error> where
    I: Input,

impl<J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl<T> Decode for VecDeque<T> where
    T: Decode,

pub fn decode<I>(input: &mut I) -> Result<VecDeque<T>, Error> where
    I: Input,

impl<T, const N: usize> Decode for [T; N] where
    T: Decode,

pub fn decode<I>(input: &mut I) -> Result<[T; N], Error> where
    I: Input,

impl<T> Decode for Option<T> where
    T: Decode,

pub fn decode<I>(input: &mut I) -> Result<Option<T>, Error> where
    I: Input,

impl Decode for NonZeroU32

pub fn decode<I>(input: &mut I) -> Result<NonZeroU32, Error> where
    I: Input,

impl Decode for ()

pub fn decode<I>(&mut I) -> Result<(), Error> where
    I: Input,

impl<D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    G0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode,

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input,

impl Decode for u16

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u16, Error> where
    I: Input,

[src]

impl Decode for StorageMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for RuntimeMetadataDeprecated

[src]

pub fn decode<I>(_input: &mut I) -> Result<RuntimeMetadataDeprecated, Error> where
    I: Input,

[src]

impl Decode for StorageEntryMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ModuleMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ModuleMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageEntryType

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryType, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for RuntimeMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RuntimeMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ExtrinsicMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExtrinsicMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for RuntimeMetadataPrefixed

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RuntimeMetadataPrefixed, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageHasher

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageHasher, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageEntryModifier

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryModifier, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for RuntimeMetadataV13

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RuntimeMetadataV13, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Public

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Public

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for OpaquePeerId

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaquePeerId, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for LogLevelFilter

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LogLevelFilter, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Timestamp

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Timestamp, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for OpaqueMetadata

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueMetadata, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for HostError

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HostError, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for HttpError

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpError, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ExternEntity

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExternEntity, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Signature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ChangesTrieConfiguration

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ChangesTrieConfiguration, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for AccountId32

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<AccountId32, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for LogLevel

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LogLevel, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for CryptoTypeId

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CryptoTypeId, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Signature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageKind

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageKind, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Duration

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Duration, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for NeverNativeValue

[src]

pub fn decode<I>(&mut I) -> Result<NeverNativeValue, Error> where
    I: Input,

[src]

impl Decode for OpaqueMultiaddr

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueMultiaddr, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Entry

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Entry, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for HttpRequestStatus

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpRequestStatus, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for HttpRequestId

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpRequestId, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for EnvironmentDefinition

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<EnvironmentDefinition, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for OpaqueNetworkState

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueNetworkState, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for KeyTypeId

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<KeyTypeId, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for LocalizedSignature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LocalizedSignature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for DeriveJunction

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<DeriveJunction, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for CryptoTypePublicPair

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CryptoTypePublicPair, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Signature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Public

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Value

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Value, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ReturnValue

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ReturnValue, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageKey

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageKey, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageData

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageData, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for TrackedStorageKey

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TrackedStorageKey, Error> where
    __CodecInputEdqy: Input,

impl Decode for U256

pub fn decode<I>(input: &mut I) -> Result<U256, Error> where
    I: Input,

impl Decode for U512

pub fn decode<I>(input: &mut I) -> Result<U512, Error> where
    I: Input,

impl Decode for H160

pub fn decode<I>(input: &mut I) -> Result<H160, Error> where
    I: Input,

impl Decode for H512

pub fn decode<I>(input: &mut I) -> Result<H512, Error> where
    I: Input,

impl Decode for H128

pub fn decode<I>(input: &mut I) -> Result<H128, Error> where
    I: Input,

impl Decode for H256

pub fn decode<I>(input: &mut I) -> Result<H256, Error> where
    I: Input,

impl Decode for U128

pub fn decode<I>(input: &mut I) -> Result<U128, Error> where
    I: Input,

[src]

impl<T> Decode for Crossing<T> where
    T: Encode + Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Crossing<T>, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for EcdsaVerifyError

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<EcdsaVerifyError, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for StorageProof

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageProof, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for CompactProof

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CompactProof, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ArithmeticError

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ArithmeticError, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for TestSignature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TestSignature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for BadOrigin

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BadOrigin, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for UintAuthorityId

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<UintAuthorityId, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for OpaqueExtrinsic

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueExtrinsic, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for LookupError

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LookupError, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Xt> Decode for ExtrinsicWrapper<Xt> where
    Xt: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExtrinsicWrapper<Xt>, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Time

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Time, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Hash> Decode for DigestItem<Hash> where
    Hash: Decode,

[src]

pub fn decode<I>(input: &mut I) -> Result<DigestItem<Hash>, Error> where
    I: Input,

[src]

impl Decode for MultiSignature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiSignature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Justifications

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Justifications, Error> where
    __CodecInputEdqy: Input,

[src]

impl<B> Decode for BlockAndTimeDeadline<B> where
    B: BlockNumberProvider,
    <B as BlockNumberProvider>::BlockNumber: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BlockAndTimeDeadline<B>, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Info> Decode for DispatchErrorWithPostInfo<Info> where
    Info: Eq + PartialEq<Info> + Clone + Copy + Encode + Decode + Printable,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<DispatchErrorWithPostInfo<Info>, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Hash> Decode for Digest<Hash> where
    Vec<DigestItem<Hash>, Global>: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Digest<Hash>, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Xt> Decode for Block<Xt> where
    Vec<Xt, Global>: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Block<Xt>, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for RuntimeString

[src]

pub fn decode<I>(value: &mut I) -> Result<RuntimeString, Error> where
    I: Input,

[src]

impl<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Call: Decode,
    Extra: SignedExtension,
    Address: Decode,
    Signature: Decode,

[src]

pub fn decode<I>(
    input: &mut I
) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extra>, Error> where
    I: Input,

[src]

impl Decode for MultiSigner

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiSigner, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Block> Decode for SignedBlock<Block> where
    Block: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<SignedBlock<Block>, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for TokenError

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TokenError, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for ChangesTrieSignal

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ChangesTrieSignal, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Number, Hash> Decode for Header<Number, Hash> where
    Hash: Hash,
    Number: Copy + Into<U256> + TryFrom<U256> + HasCompact,
    <Hash as Hash>::Output: Decode,
    Digest<<Hash as Hash>::Output>: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Header<Number, Hash>, Error> where
    __CodecInputEdqy: Input,

[src]

impl<AccountId, AccountIndex> Decode for MultiAddress<AccountId, AccountIndex> where
    AccountId: Decode,
    AccountIndex: HasCompact,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiAddress<AccountId, AccountIndex>, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Era

[src]

pub fn decode<I>(input: &mut I) -> Result<Era, Error> where
    I: Input,

[src]

impl Decode for AnySignature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<AnySignature, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Call, Extra> Decode for TestXt<Call, Extra> where
    Call: Decode,
    Option<(u64, Extra)>: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TestXt<Call, Extra>, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Header, Extrinsic> Decode for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,
    Header: Decode,
    Vec<Extrinsic, Global>: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Block<Header, Extrinsic>, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Signature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Signature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Signature

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Public

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Public

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for Public

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for FixedI64

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedI64, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for FixedU128

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedU128, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for BigUint

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BigUint, Error> where
    __CodecInputEdqy: Input,

[src]

impl Decode for PerU16

[src]

pub fn decode<I>(input: &mut I) -> Result<PerU16, Error> where
    I: Input,

[src]

impl Decode for Perquintill

[src]

pub fn decode<I>(input: &mut I) -> Result<Perquintill, Error> where
    I: Input,

[src]

impl Decode for Permill

[src]

pub fn decode<I>(input: &mut I) -> Result<Permill, Error> where
    I: Input,

[src]

impl Decode for Perbill

[src]

pub fn decode<I>(input: &mut I) -> Result<Perbill, Error> where
    I: Input,

[src]

impl Decode for Percent

[src]

pub fn decode<I>(input: &mut I) -> Result<Percent, Error> where
    I: Input,

[src]

impl Decode for FixedI128

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedI128, Error> where
    __CodecInputEdqy: Input,

[src]

impl<Reporter, Offender> Decode for OffenceDetails<Reporter, Offender> where
    Offender: Decode,
    Vec<Reporter, Global>: Decode,

[src]

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OffenceDetails<Reporter, Offender>, Error> where
    __CodecInputEdqy: Input,

Implementors

[src]

impl Decode for Void

[src]

impl Decode for KillStorageResult

[src]

impl Decode for BalanceStatus

[src]

impl Decode for DispatchClass

[src]

impl Decode for Pays

[src]

impl Decode for DispatchError

[src]

impl Decode for InvalidTransaction

[src]

impl Decode for TransactionSource

[src]

impl Decode for TransactionValidityError

[src]

impl Decode for UnknownTransaction

[src]

impl Decode for ErrorMetadata

[src]

impl Decode for FunctionArgumentMetadata

[src]

impl Decode for FunctionMetadata

[src]

impl Decode for ModuleConstantMetadata

[src]

impl Decode for EventMetadata

[src]

impl Decode for OuterEventMetadata

[src]

impl Decode for CheckInherentsResult

[src]

impl Decode for PalletId

[src]

impl Decode for StorageInfo

[src]

impl Decode for StorageVersion

[src]

impl Decode for WithdrawReasons

[src]

impl Decode for DispatchInfo

[src]

impl Decode for PostDispatchInfo

[src]

impl Decode for RuntimeDbWeight

[src]

impl Decode for InherentData

[src]

impl Decode for ValidTransaction

[src]

impl<B, O> Decode for DecodeDifferent<B, O> where
    O: Decode + 'static,
    B: 'static,

[src]

impl<Balance> Decode for WeightToFeeCoefficient<Balance> where
    Balance: Decode,
    Balance: Decode,

[src]

impl<BlockNumber> Decode for DispatchTime<BlockNumber> where
    BlockNumber: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode,

[src]

impl<K, V, S> Decode for BoundedBTreeMap<K, V, S> where
    K: Decode + Ord,
    V: Decode,
    S: Get<u32>,

impl<T> Decode for Vec<T, Global> where
    T: Decode,

[src]

impl<T> Decode for PerDispatchClass<T> where
    T: Decode,
    T: Decode,
    T: Decode,
    T: Decode,
    T: Decode,
    T: Decode,

impl<T> Decode for PhantomData<T>

impl<T, E> Decode for Result<T, E> where
    T: Decode,
    E: Decode,

[src]

impl<T, S> Decode for BoundedBTreeSet<T, S> where
    T: Decode + Ord,
    S: Get<u32>,

impl<T, X> Decode for X where
    T: Decode + Into<X>,
    X: WrapperTypeDecode<Wrapped = T>,

[src]

impl<T: Decode, S: Get<u32>> Decode for BoundedVec<T, S>

[src]

impl<T: Decode, S: Get<u32>> Decode for WeakBoundedVec<T, S>

`impl<H, N, V> Decode for ForkTree<H, N, V> where Vec<Node<H, N, V>>: Decode, Vec<Node<H, N, V>>: Decode, Option<N>: Decode, Option<N>: Decode,`

`impl Decode for BenchmarkParameter`

`impl Decode for BenchmarkBatch`

`impl Decode for BenchmarkBatchSplitResults`

`impl Decode for BenchmarkResults`

`impl Decode for BenchmarkConfig`

`impl Decode for BenchmarkList`

`impl Decode for BenchmarkMetadata`

`impl<B, O> Decode for DecodeDifferent<B, O> where B: 'static, O: Decode + 'static,`

`impl Decode for FunctionMetadata`

`impl Decode for FunctionArgumentMetadata`

`impl Decode for OuterEventMetadata`

`impl Decode for EventMetadata`

`impl Decode for StorageEntryMetadata`

`impl Decode for ModuleConstantMetadata`

`impl Decode for ErrorMetadata`

`impl Decode for StorageHasher`

`impl Decode for StorageEntryType`

`impl Decode for StorageEntryModifier`

`impl Decode for StorageMetadata`

`impl Decode for RuntimeMetadataPrefixed`

`impl Decode for ExtrinsicMetadata`

`impl Decode for RuntimeMetadata`

`impl Decode for RuntimeMetadataDeprecated`

`impl Decode for RuntimeMetadataV13`

`impl Decode for ModuleMetadata`

`impl<T: Config> Decode for Call<T>`

`impl Decode for BlockLength`

`impl Decode for WeightsPerClass`

`impl Decode for BlockWeights`

`impl<T: Config + Send + Sync> Decode for CheckGenesis<T> where PhantomData<T>: Decode, PhantomData<T>: Decode,`

`impl<T: Config + Send + Sync> Decode for CheckMortality<T> where PhantomData<T>: Decode, PhantomData<T>: Decode,`

`impl<T: Config> Decode for CheckNonce<T> where T::Index: HasCompact,`

`impl<T: Config + Send + Sync> Decode for CheckSpecVersion<T> where PhantomData<T>: Decode, PhantomData<T>: Decode,`

`impl<T: Config + Send + Sync> Decode for CheckTxVersion<T> where PhantomData<T>: Decode, PhantomData<T>: Decode,`

`impl<T: Config + Send + Sync> Decode for CheckWeight<T> where PhantomData<T>: Decode, PhantomData<T>: Decode,`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl Decode for Phase`

`impl<E: Parameter + Member, T> Decode for EventRecord<E, T> where E: Decode, E: Decode, Vec<T>: Decode, Vec<T>: Decode,`

`impl<AccountId> Decode for RawOrigin<AccountId> where AccountId: Decode, AccountId: Decode,`

`impl<Index, AccountData> Decode for AccountInfo<Index, AccountData> where Index: Decode, Index: Decode, AccountData: Decode, AccountData: Decode,`

`impl Decode for LastRuntimeUpgradeInfo`

`impl Decode for ProxyType`

`impl Decode for SessionKeys`

`impl Decode for NposSolution16`

`impl Decode for Event`

`impl Decode for OriginCaller`

`impl Decode for Call`

`impl Decode for SessionKeys`

`impl Decode for Event`

`impl Decode for OriginCaller`

`impl Decode for Call`

`impl<Balance, AccountId, DepositBalance> Decode for AssetDetails<Balance, AccountId, DepositBalance> where AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, DepositBalance: Decode, DepositBalance: Decode, Balance: Decode, Balance: Decode,`

`impl<Balance, DepositBalance> Decode for Approval<Balance, DepositBalance> where Balance: Decode, Balance: Decode, DepositBalance: Decode, DepositBalance: Decode,`

`impl<Balance, Extra> Decode for AssetBalance<Balance, Extra> where Balance: Decode, Balance: Decode, Extra: Decode, Extra: Decode,`

`impl<DepositBalance, BoundedString> Decode for AssetMetadata<DepositBalance, BoundedString> where DepositBalance: Decode, DepositBalance: Decode, BoundedString: Decode, BoundedString: Decode, BoundedString: Decode, BoundedString: Decode,`

`impl Decode for DestroyWitness`

`impl Decode for ConversionError`

impl<T: Config<I>, I: 'static> Decode for Event<T, I> where T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AssetId: Decode, T::AssetId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AssetId: Decode, T::AssetId: Decode,

`impl<T: Config<I>, I: 'static> Decode for Call<T, I>`

`impl<T: Config> Decode for PendingSwap<T> where T::AccountId: Decode, T::AccountId: Decode, T::SwapAction: Decode, T::SwapAction: Decode, T::BlockNumber: Decode, T::BlockNumber: Decode,`

`impl<AccountId, C: ReservableCurrency<AccountId>> Decode for BalanceSwapAction<AccountId, C> where <C as Currency<AccountId>>::Balance: Decode, <C as Currency<AccountId>>::Balance: Decode, PhantomData<C>: Decode, PhantomData<C>: Decode,`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, PendingSwap<T>: Decode, PendingSwap<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

impl<T: Config<I>, I: 'static> Decode for Event<T, I> where T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Balance: Decode, T::Balance: Decode,

`impl<T: Config<I>, I: 'static> Decode for Call<T, I>`

`impl Decode for Reasons`

`impl<Balance> Decode for BalanceLock<Balance> where Balance: Decode, Balance: Decode,`

`impl<ReserveIdentifier, Balance> Decode for ReserveData<ReserveIdentifier, Balance> where ReserveIdentifier: Decode, ReserveIdentifier: Decode, Balance: Decode, Balance: Decode,`

`impl<Balance> Decode for AccountData<Balance> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

`impl<AccountId, Balance, BlockNumber> Decode for Bounty<AccountId, Balance, BlockNumber> where AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, BountyStatus<AccountId, BlockNumber>: Decode, BountyStatus<AccountId, BlockNumber>: Decode,`

`impl<AccountId, BlockNumber> Decode for BountyStatus<AccountId, BlockNumber> where AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, BlockNumber: Decode, BlockNumber: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<Balance, AccountId> Decode for RawEvent<Balance, AccountId> where Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode,`

`impl<T: Config> Decode for Call<T> where <T::Lookup as StaticLookup>::Source: Decode, <T::Lookup as StaticLookup>::Source: Decode, <T::Lookup as StaticLookup>::Source: Decode, <T::Lookup as StaticLookup>::Source: Decode, BalanceOf<T>: HasCompact, BalanceOf<T>: HasCompact,`

`impl<AccountId, I> Decode for RawOrigin<AccountId, I> where AccountId: Decode, AccountId: Decode, PhantomData<I>: Decode, PhantomData<I>: Decode,`

`impl<AccountId, BlockNumber> Decode for Votes<AccountId, BlockNumber> where Vec<AccountId>: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl Decode for Instance1`

`impl Decode for Instance2`

`impl Decode for Instance3`

`impl Decode for Instance4`

`impl Decode for Instance5`

`impl Decode for Instance6`

`impl Decode for Instance7`

`impl Decode for Instance8`

`impl Decode for Instance9`

`impl Decode for Instance10`

`impl Decode for Instance11`

`impl Decode for Instance12`

`impl Decode for Instance13`

`impl Decode for Instance14`

`impl Decode for Instance15`

`impl Decode for Instance16`

`impl Decode for DefaultInstance`

`impl<Hash, AccountId, I> Decode for RawEvent<Hash, AccountId, I> where AccountId: Decode, AccountId: Decode, Hash: Decode, Hash: Decode, AccountId: Decode, AccountId: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode,`

impl<T: Config<I>, I: Instance> Decode for Call<T, I> where Vec<T::AccountId>: Decode, Vec<T::AccountId>: Decode, Option<T::AccountId>: Decode, Option<T::AccountId>: Decode, Box<<T as Config<I>>::Proposal>: Decode, Box<<T as Config<I>>::Proposal>: Decode, Box<<T as Config<I>>::Proposal>: Decode, Box<<T as Config<I>>::Proposal>: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode,

`impl<T: Config> Decode for Schedule<T> where InstructionWeights<T>: Decode, InstructionWeights<T>: Decode, HostFnWeights<T>: Decode, HostFnWeights<T>: Decode,`

`impl Decode for Limits`

`impl<T: Config> Decode for InstructionWeights<T> where PhantomData<T>: Default,`

`impl<T: Config> Decode for HostFnWeights<T> where PhantomData<T>: Default,`

impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::Hash: Decode, T::Hash: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode,

`impl<T: Config> Decode for Call<T> where T::AccountId: UncheckedFrom<T::Hash>, T::AccountId: AsRef<[u8]>,`

`impl<T> Decode for ContractResult<T> where T: Decode, T: Decode,`

`impl Decode for ContractAccessError`

`impl<BlockNumber> Decode for RentProjection<BlockNumber> where BlockNumber: Decode, BlockNumber: Decode,`

`impl Decode for ReturnFlags`

`impl Decode for ExecReturnValue`

`impl<AccountId, BlockNumber> Decode for InstantiateReturnValue<AccountId, BlockNumber> where AccountId: Decode, AccountId: Decode, Option<RentProjection<BlockNumber>>: Decode, Option<RentProjection<BlockNumber>>: Decode,`

`impl<Hash> Decode for Code<Hash> where Hash: Decode, Hash: Decode,`

`impl Decode for Conviction`

`impl<Balance> Decode for Tally<Balance> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

`impl<Balance> Decode for Delegations<Balance> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

`impl<BlockNumber, Hash, Balance> Decode for ReferendumStatus<BlockNumber, Hash, Balance> where BlockNumber: Decode, BlockNumber: Decode, Hash: Decode, Hash: Decode, BlockNumber: Decode, BlockNumber: Decode, Tally<Balance>: Decode, Tally<Balance>: Decode,`

`impl<BlockNumber, Hash, Balance> Decode for ReferendumInfo<BlockNumber, Hash, Balance> where ReferendumStatus<BlockNumber, Hash, Balance>: Decode, ReferendumStatus<BlockNumber, Hash, Balance>: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl Decode for Vote`

`impl<Balance> Decode for AccountVote<Balance> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

impl<Balance, AccountId, BlockNumber> Decode for Voting<Balance, AccountId, BlockNumber> where Vec<(ReferendumIndex, AccountVote<Balance>)>: Decode, Vec<(ReferendumIndex, AccountVote<Balance>)>: Decode, Delegations<Balance>: Decode, Delegations<Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode, Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, Delegations<Balance>: Decode, Delegations<Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode,

`impl Decode for VoteThreshold`

`impl<AccountId, Balance, BlockNumber> Decode for PreimageStatus<AccountId, Balance, BlockNumber> where BlockNumber: Decode, BlockNumber: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, BlockNumber: Decode, BlockNumber: Decode, Option<BlockNumber>: Decode, Option<BlockNumber>: Decode,`

impl<T: Config> Decode for Event<T> where <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, Vec<T::AccountId>: Decode, Vec<T::AccountId>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode, T::BlockNumber: Decode, T::BlockNumber: Decode, T::Hash: Decode, T::Hash: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::Hash: Decode, T::Hash: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode,

`impl<T: Config> Decode for Call<T>`

`impl<AccountId, Balance: HasCompact, Solution> Decode for SignedSubmission<AccountId, Balance, Solution> where AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, RawSolution<Solution>: Decode, RawSolution<Solution>: Decode, Balance: Decode, Balance: Decode,`

`impl<Bn> Decode for Phase<Bn> where Bn: Decode, (bool, Bn): Decode,`

`impl Decode for ElectionCompute`

`impl<S> Decode for RawSolution<S> where S: Decode, S: Decode,`

`impl<A> Decode for ReadySolution<A> where Supports<A>: Decode, Supports<A>: Decode,`

`impl<A> Decode for RoundSnapshot<A> where Vec<(A, VoteWeight, Vec<A>)>: Decode, Vec<(A, VoteWeight, Vec<A>)>: Decode, Vec<A>: Decode, Vec<A>: Decode,`

`impl Decode for SolutionOrSnapshotSize`

`impl<T: Config> Decode for Event<T> where <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<Balance> Decode for VoterInfo<Balance> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, Vec<T::AccountId>: Decode, Vec<T::AccountId>: Decode, Vec<T::AccountId>: Decode, Vec<T::AccountId>: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl Decode for Renouncing`

`impl<AccountId, Balance> Decode for Voter<AccountId, Balance> where Vec<AccountId>: Decode, Vec<AccountId>: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

`impl<AccountId, Balance> Decode for SeatHolder<AccountId, Balance> where AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

impl<T: Config> Decode for Event<T> where Vec<(<T as Config>::AccountId, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance)>: Decode, Vec<(<T as Config>::AccountId, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance)>: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <T as Config>::AccountId: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

`impl<T: Config> Decode for Call<T>`

`impl<T: Config> Decode for Event<T> where <T as Config>::Balance: Decode, <T as Config>::Balance: Decode, <T as Config>::Balance: Decode, <T as Config>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, <T as Config>::Balance: Decode, <T as Config>::Balance: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<T: Config + Send + Sync> Decode for WatchDummy<T> where PhantomData<T>: Decode, PhantomData<T>: Decode,`

`impl Decode for Public`

`impl Decode for Signature`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<Public, BlockNumber> Decode for PricePayload<Public, BlockNumber> where BlockNumber: Decode, BlockNumber: Decode, Public: Decode, Public: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl Decode for EnlistedParticipant`

`impl<Balance, AccountId> Decode for GiltBid<Balance, AccountId> where Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode,`

`impl<Balance, AccountId, BlockNumber> Decode for ActiveGilt<Balance, AccountId, BlockNumber> where Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<Balance> Decode for ActiveGiltsTotal<Balance> where Balance: Decode, Balance: Decode,`

impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::BlockNumber: Decode, T::BlockNumber: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

`impl<T: Config> Decode for Call<T>`

`impl Decode for GrandpaTimeSlot`

`impl Decode for Event`

`impl<T: Config> Decode for Call<T>`

`impl<N> Decode for StoredPendingChange<N> where N: Decode, N: Decode, N: Decode, N: Decode, Option<N>: Decode, Option<N>: Decode,`

`impl<N> Decode for StoredState<N> where N: Decode, N: Decode, N: Decode, N: Decode, N: Decode, N: Decode, N: Decode, N: Decode,`

`impl Decode for Data`

`impl<Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq> Decode for Judgement<Balance> where Balance: Decode, Balance: Decode,`

`impl Decode for IdentityFields`

`impl<FieldLimit: Get<u32>> Decode for IdentityInfo<FieldLimit> where BoundedVec<(Data, Data), FieldLimit>: Decode, BoundedVec<(Data, Data), FieldLimit>: Decode,`

`impl<Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq, MaxJudgements: Get<u32>, MaxAdditionalFields: Get<u32>> Decode for Registration<Balance, MaxJudgements, MaxAdditionalFields>`

`impl<Balance: Encode + Decode + Clone + Debug + Eq + PartialEq, AccountId: Encode + Decode + Clone + Debug + Eq + PartialEq> Decode for RegistrarInfo<Balance, AccountId> where AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode,`

impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

`impl<T: Config> Decode for Call<T>`

`impl<BlockNumber> Decode for Heartbeat<BlockNumber> where BlockNumber: PartialEq + Eq + Decode + Encode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<T: Config> Decode for Event<T> where T::AuthorityId: Decode, T::AuthorityId: Decode, Vec<IdentificationTuple<T>>: Decode, Vec<IdentificationTuple<T>>: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountIndex: Decode, T::AccountIndex: Decode, T::AccountIndex: Decode, T::AccountIndex: Decode, T::AccountIndex: Decode, T::AccountIndex: Decode, T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<BlockNumber, Balance> Decode for LotteryConfig<BlockNumber, Balance> where Balance: Decode, Balance: Decode, BlockNumber: Decode, BlockNumber: Decode, BlockNumber: Decode, BlockNumber: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl Decode for Instance1`

`impl Decode for Instance2`

`impl Decode for Instance3`

`impl Decode for Instance4`

`impl Decode for Instance5`

`impl Decode for Instance6`

`impl Decode for Instance7`

`impl Decode for Instance8`

`impl Decode for Instance9`

`impl Decode for Instance10`

`impl Decode for Instance11`

`impl Decode for Instance12`

`impl Decode for Instance13`

`impl Decode for Instance14`

`impl Decode for Instance15`

`impl Decode for Instance16`

`impl Decode for DefaultInstance`

`impl<AccountId, Event, I> Decode for RawEvent<AccountId, Event, I> where PhantomData<(AccountId, Event)>: Decode, PhantomData<(AccountId, Event)>: Decode,`

`impl<T: Config<I>, I: Instance> Decode for Call<T, I> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, Vec<T::AccountId>: Decode, Vec<T::AccountId>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config<I>, I: 'static> Decode for Call<T, I>`

`impl<H: Hash, L: FullLeaf + Decode> Decode for DataOrHash<H, L>`

`impl<H, T: Decode> Decode for Compact<H, T>`

`impl<Hash> Decode for Proof<Hash> where Vec<Hash>: Decode, Vec<Hash>: Decode,`

`impl Decode for Error`

`impl Decode for EncodableOpaqueLeaf`

`impl<BlockNumber> Decode for Timepoint<BlockNumber> where BlockNumber: Decode, BlockNumber: Decode,`

`impl<BlockNumber, Balance, AccountId> Decode for Multisig<BlockNumber, Balance, AccountId> where Timepoint<BlockNumber>: Decode, Timepoint<BlockNumber>: Decode, Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode,`

impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, Timepoint<T::BlockNumber>: Decode, Timepoint<T::BlockNumber>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, Timepoint<T::BlockNumber>: Decode, Timepoint<T::BlockNumber>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, Timepoint<T::BlockNumber>: Decode, Timepoint<T::BlockNumber>: Decode, T::AccountId: Decode, T::AccountId: Decode,

`impl<T: Config> Decode for Call<T>`

impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

`impl<T: Config> Decode for Call<T>`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, Vec<(PeerId, T::AccountId)>: Decode, Vec<(PeerId, T::AccountId)>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl Decode for Event`

`impl<T: Config> Decode for Call<T>`

`impl<AccountId, ProxyType, BlockNumber> Decode for ProxyDefinition<AccountId, ProxyType, BlockNumber> where AccountId: Decode, AccountId: Decode, ProxyType: Decode, ProxyType: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<AccountId, Hash, BlockNumber> Decode for Announcement<AccountId, Hash, BlockNumber> where AccountId: Decode, AccountId: Decode, Hash: Decode, Hash: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ProxyType: Decode, T::ProxyType: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::CallHasher as Hash>::Output: Decode, <<T as Config>::CallHasher as Hash>::Output: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<BlockNumber, Balance, AccountId> Decode for ActiveRecovery<BlockNumber, Balance, AccountId> where BlockNumber: Decode, BlockNumber: Decode, Balance: Decode, Balance: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode,`

`impl<BlockNumber, Balance, AccountId> Decode for RecoveryConfig<BlockNumber, Balance, AccountId> where BlockNumber: Decode, BlockNumber: Decode, Balance: Decode, Balance: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode,`

impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode,

`impl<T: Config> Decode for Call<T>`

`impl<Call, BlockNumber, PalletsOrigin, AccountId> Decode for ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId> where Call: Decode, Call: Decode, Option<Period<BlockNumber>>: Decode, Option<Period<BlockNumber>>: Decode, PalletsOrigin: Decode, PalletsOrigin: Decode, PhantomData<AccountId>: Decode, PhantomData<AccountId>: Decode,`

`impl<T: Config> Decode for Event<T> where T::BlockNumber: Decode, T::BlockNumber: Decode, T::BlockNumber: Decode, T::BlockNumber: Decode, TaskAddress<T::BlockNumber>: Decode, TaskAddress<T::BlockNumber>: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<T: Config<I>, I: 'static> Decode for Event<T, I>`

`impl<T: Config<I>, I: 'static> Decode for Call<T, I>`

`impl<T: Config> Decode for Call<T>`

`impl Decode for Event`

`impl<T: Config> Decode for Call<T> where T::Keys: Decode, T::Keys: Decode,`

`impl Decode for Vote`

`impl Decode for Judgement`

`impl<Balance, BlockNumber> Decode for Payout<Balance, BlockNumber> where Balance: Decode, Balance: Decode, BlockNumber: Decode, BlockNumber: Decode, BlockNumber: Decode, BlockNumber: Decode, Balance: Decode, Balance: Decode,`

`impl Decode for VouchingStatus`

`impl<AccountId, Balance> Decode for Bid<AccountId, Balance> where AccountId: Decode, AccountId: Decode, BidKind<AccountId, Balance>: Decode, BidKind<AccountId, Balance>: Decode, Balance: Decode, Balance: Decode,`

`impl<AccountId, Balance> Decode for BidKind<AccountId, Balance> where Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode,`

`impl Decode for Instance1`

`impl Decode for Instance2`

`impl Decode for Instance3`

`impl Decode for Instance4`

`impl Decode for Instance5`

`impl Decode for Instance6`

`impl Decode for Instance7`

`impl Decode for Instance8`

`impl Decode for Instance9`

`impl Decode for Instance10`

`impl Decode for Instance11`

`impl Decode for Instance12`

`impl Decode for Instance13`

`impl Decode for Instance14`

`impl Decode for Instance15`

`impl Decode for Instance16`

`impl Decode for DefaultInstance`

impl<T: Config<I>, I: Instance> Decode for Call<T, I> where <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <T::Lookup as StaticLookup>::Source: Decode, <T::Lookup as StaticLookup>::Source: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode,

impl<AccountId, Balance, I> Decode for RawEvent<AccountId, Balance, I> where AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode,

`impl Decode for SlashingSpans`

impl<T: Config> Decode for Event<T> where BalanceOf<T>: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, BalanceOf<T>: Decode, BalanceOf<T>: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode,

`impl<T: Config> Decode for Call<T>`

`impl Decode for ActiveEraInfo`

`impl<AccountId: Ord> Decode for EraRewardPoints<AccountId> where BTreeMap<AccountId, RewardPoint>: Decode, BTreeMap<AccountId, RewardPoint>: Decode,`

`impl<AccountId> Decode for RewardDestination<AccountId> where AccountId: Decode, AccountId: Decode,`

`impl Decode for ValidatorPrefs`

`impl<Balance: HasCompact> Decode for UnlockChunk<Balance> where Balance: HasCompact,`

`impl<AccountId, Balance: HasCompact> Decode for StakingLedger<AccountId, Balance> where AccountId: Decode, AccountId: Decode, Vec<UnlockChunk<Balance>>: Decode, Vec<UnlockChunk<Balance>>: Decode, Balance: HasCompact, Balance: HasCompact,`

`impl<AccountId> Decode for Nominations<AccountId> where Vec<AccountId>: Decode, Vec<AccountId>: Decode,`

`impl<AccountId, Balance: HasCompact> Decode for IndividualExposure<AccountId, Balance> where AccountId: Decode, AccountId: Decode, Balance: HasCompact,`

`impl<AccountId, Balance: HasCompact> Decode for Exposure<AccountId, Balance> where Vec<IndividualExposure<AccountId, Balance>>: Decode, Vec<IndividualExposure<AccountId, Balance>>: Decode, Balance: HasCompact, Balance: HasCompact,`

`impl<AccountId, Balance: HasCompact> Decode for UnappliedSlash<AccountId, Balance> where AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, Vec<(AccountId, Balance)>: Decode, Vec<(AccountId, Balance)>: Decode, Vec<AccountId>: Decode, Vec<AccountId>: Decode, Balance: Decode, Balance: Decode,`

`impl Decode for Forcing`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

impl<AccountId: Parameter, Balance: Parameter, BlockNumber: Parameter, Hash: Parameter> Decode for OpenTip<AccountId, Balance, BlockNumber, Hash> where Hash: Decode, Hash: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, Option<BlockNumber>: Decode, Option<BlockNumber>: Decode, Vec<(AccountId, Balance)>: Decode, Vec<(AccountId, Balance)>: Decode,

impl<Balance, AccountId, Hash> Decode for RawEvent<Balance, AccountId, Hash> where Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, Hash: Decode, Hash: Decode, Hash: Decode, Hash: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode,

`impl<T: Config> Decode for Call<T> where T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode, T::AccountId: Decode, T::AccountId: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, T::Hash: Decode, BalanceOf<T>: HasCompact, BalanceOf<T>: HasCompact,`

`impl<Balance> Decode for InclusionFee<Balance> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode,`

`impl<Balance> Decode for FeeDetails<Balance> where Option<InclusionFee<Balance>>: Decode, Option<InclusionFee<Balance>>: Decode, Balance: Decode, Balance: Decode,`

`impl<Balance> Decode for RuntimeDispatchInfo<Balance> where Balance: Decode, Balance: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl<T: Config> Decode for ChargeTransactionPayment<T> where <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::Balance: HasCompact,`

`impl Decode for TransactionInfo`

`impl<T: Config> Decode for Event<T>`

`impl<T: Config> Decode for Call<T>`

`impl<AccountId, Balance> Decode for Proposal<AccountId, Balance> where AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode, AccountId: Decode, AccountId: Decode, Balance: Decode, Balance: Decode,`

impl<T: Config<I>, I: 'static> Decode for Event<T, I> where BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, T::AccountId: Decode, T::AccountId: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode, BalanceOf<T, I>: Decode,

`impl<T: Config<I>, I: 'static> Decode for Call<T, I>`

`impl<AccountId, DepositBalance> Decode for ClassDetails<AccountId, DepositBalance> where AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, AccountId: Decode, DepositBalance: Decode, DepositBalance: Decode,`

`impl Decode for DestroyWitness`

`impl<AccountId, DepositBalance> Decode for InstanceDetails<AccountId, DepositBalance> where AccountId: Decode, AccountId: Decode, Option<AccountId>: Decode, Option<AccountId>: Decode, DepositBalance: Decode, DepositBalance: Decode,`

`impl<DepositBalance, StringLimit: Get<u32>> Decode for ClassMetadata<DepositBalance, StringLimit> where DepositBalance: Decode, DepositBalance: Decode, BoundedVec<u8, StringLimit>: Decode, BoundedVec<u8, StringLimit>: Decode,`

`impl<DepositBalance, StringLimit: Get<u32>> Decode for InstanceMetadata<DepositBalance, StringLimit> where DepositBalance: Decode, DepositBalance: Decode, BoundedVec<u8, StringLimit>: Decode, BoundedVec<u8, StringLimit>: Decode,`

impl<T: Config<I>, I: 'static> Decode for Event<T, I> where T::ClassId: Decode, T::ClassId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::AccountId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, BoundedVec<u8, T::StringLimit>: Decode, BoundedVec<u8, T::StringLimit>: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, BoundedVec<u8, T::StringLimit>: Decode, BoundedVec<u8, T::StringLimit>: Decode, T::ClassId: Decode, T::ClassId: Decode, T::InstanceId: Decode, T::InstanceId: Decode, T::ClassId: Decode, T::ClassId: Decode, Vec<T::InstanceId>: Decode, Vec<T::InstanceId>: Decode, T::ClassId: Decode, T::ClassId: Decode, Option<T::InstanceId>: Decode, Option<T::InstanceId>: Decode, BoundedVec<u8, T::KeyLimit>: Decode, BoundedVec<u8, T::KeyLimit>: Decode, BoundedVec<u8, T::ValueLimit>: Decode, BoundedVec<u8, T::ValueLimit>: Decode, T::ClassId: Decode, T::ClassId: Decode, Option<T::InstanceId>: Decode, Option<T::InstanceId>: Decode, BoundedVec<u8, T::KeyLimit>: Decode, BoundedVec<u8, T::KeyLimit>: Decode,

`impl<T: Config<I>, I: 'static> Decode for Call<T, I>`

`impl Decode for Event`

`impl<T: Config> Decode for Call<T>`

`impl<Balance, BlockNumber> Decode for VestingInfo<Balance, BlockNumber> where Balance: Decode, Balance: Decode, Balance: Decode, Balance: Decode, BlockNumber: Decode, BlockNumber: Decode,`

`impl<T: Config> Decode for Event<T> where T::AccountId: Decode, T::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, T::AccountId: Decode, T::AccountId: Decode,`

`impl<T: Config> Decode for Call<T>`

`impl Decode for Epoch`

`impl<Hash, Number, E: Epoch> Decode for EpochChangesV0<Hash, Number, E> where ForkTree<Hash, Number, PersistedEpoch<E>>: Decode, ForkTree<Hash, Number, PersistedEpoch<E>>: Decode,`

`impl<E: Epoch> Decode for EpochHeader<E> where E::Slot: Decode, E::Slot: Decode, E::Slot: Decode, E::Slot: Decode,`

`impl<E: Epoch> Decode for PersistedEpoch<E> where E: Decode, E: Decode, E: Decode, E: Decode, E: Decode, E: Decode,`

`impl<E: Epoch> Decode for PersistedEpochHeader<E> where EpochHeader<E>: Decode, EpochHeader<E>: Decode, EpochHeader<E>: Decode, EpochHeader<E>: Decode, EpochHeader<E>: Decode, EpochHeader<E>: Decode,`

`impl<Hash, Number, E: Epoch> Decode for EpochChanges<Hash, Number, E> where ForkTree<Hash, Number, PersistedEpochHeader<E>>: Decode, ForkTree<Hash, Number, PersistedEpochHeader<E>>: Decode, BTreeMap<(Hash, Number), PersistedEpoch<E>>: Decode, BTreeMap<(Hash, Number), PersistedEpoch<E>>: Decode,`

`impl<Difficulty> Decode for PowIntermediate<Difficulty> where Option<Difficulty>: Decode, Option<Difficulty>: Decode,`

`impl<Difficulty> Decode for PowAux<Difficulty> where Difficulty: Decode, Difficulty: Decode, Difficulty: Decode, Difficulty: Decode,`

`impl<T> Decode for SlotDuration<T> where T: Decode, T: Decode,`

`impl<H, N> Decode for AuthoritySet<H, N> where ForkTree<H, N, PendingChange<H, N>>: Decode, ForkTree<H, N, PendingChange<H, N>>: Decode, Vec<PendingChange<H, N>>: Decode, Vec<PendingChange<H, N>>: Decode, AuthoritySetChanges<N>: Decode, AuthoritySetChanges<N>: Decode,`

`impl<N> Decode for AuthoritySetChanges<N> where Vec<(u64, N)>: Decode, Vec<(u64, N)>: Decode,`

`impl<Header: HeaderT> Decode for FinalityProof<Header> where Header::Hash: Decode, Header::Hash: Decode, Vec<Header>: Decode, Vec<Header>: Decode,`

`impl<Block: BlockT> Decode for GrandpaJustification<Block> where Commit<Block>: Decode, Commit<Block>: Decode, Vec<Block::Header>: Decode, Vec<Block::Header>: Decode,`

`impl<Block: BlockT> Decode for WarpSyncFragment<Block> where Block::Header: Decode, Block::Header: Decode, GrandpaJustification<Block>: Decode, GrandpaJustification<Block>: Decode,`

`impl<Block: BlockT> Decode for WarpSyncProof<Block> where Vec<WarpSyncFragment<Block>>: Decode, Vec<WarpSyncFragment<Block>>: Decode,`

`impl<B: BlockT> Decode for Request<B> where B::Hash: Decode, B::Hash: Decode,`

`impl Decode for OldRuntimeVersion`

`impl Decode for Public`

`impl Decode for Signature`

`impl Decode for Public`

`impl Decode for Signature`

`impl Decode for Public`

`impl Decode for Signature`

`impl Decode for BigUint`

`impl Decode for FixedI64`

`impl Decode for FixedI128`

`impl Decode for FixedU128`

`impl Decode for Percent`

`impl Decode for PerU16`

`impl Decode for Permill`

`impl Decode for Perbill`

`impl Decode for Perquintill`

`impl Decode for InherentError`

`impl<AuthorityId: Codec> Decode for ConsensusLog<AuthorityId> where Vec<AuthorityId>: Decode, Vec<AuthorityId>: Decode,`

`impl Decode for SlotDuration`

`impl Decode for PrimaryPreDigest`

`impl Decode for SecondaryPlainPreDigest`

`impl Decode for SecondaryVRFPreDigest`

`impl Decode for PreDigest`

`impl Decode for NextEpochDescriptor`

`impl Decode for NextConfigDescriptor`

`impl Decode for ConsensusLog`

`impl Decode for BabeGenesisConfigurationV1`

`impl Decode for BabeGenesisConfiguration`

`impl Decode for AllowedSlots`

`impl Decode for BabeEpochConfiguration`

`impl Decode for OpaqueKeyOwnershipProof`

`impl Decode for Epoch`

`impl Decode for Slot`

`impl<Header, Id> Decode for EquivocationProof<Header, Id> where Id: Decode, Id: Decode, Header: Decode, Header: Decode, Header: Decode, Header: Decode,`

`impl Decode for VRFOutput`

`impl Decode for VRFProof`

`impl Decode for DeriveJunction`

`impl Decode for AccountId32`

`impl Decode for KeyTypeId`

`impl Decode for CryptoTypeId`

`impl Decode for CryptoTypePublicPair`

`impl Decode for ChangesTrieConfiguration`

`impl Decode for Public`

`impl Decode for Signature`

`impl Decode for Public`

`impl Decode for Signature`

`impl Decode for LocalizedSignature`

`impl Decode for StorageKind`

`impl Decode for HttpRequestId`

`impl Decode for HttpError`

`impl Decode for HttpRequestStatus`

`impl Decode for OpaqueNetworkState`

`impl Decode for OpaqueMultiaddr`

`impl Decode for Timestamp`

`impl Decode for Duration`

`impl Decode for HostError`

`impl Decode for ExternEntity`

`impl Decode for Entry`

`impl Decode for EnvironmentDefinition`

`impl Decode for Public`

`impl Decode for Signature`

`impl Decode for OpaqueMetadata`

`impl Decode for OpaquePeerId`

`impl Decode for NeverNativeValue`

`impl Decode for LogLevel`

`impl Decode for LogLevelFilter`

`impl Decode for Void`

`impl<N> Decode for ScheduledChange<N> where N: Decode, N: Decode,`

`impl<N: Codec> Decode for ConsensusLog<N> where ScheduledChange<N>: Decode, ScheduledChange<N>: Decode, N: Decode, N: Decode, ScheduledChange<N>: Decode, ScheduledChange<N>: Decode, N: Decode, N: Decode, N: Decode, N: Decode,`

`impl<H, N> Decode for EquivocationProof<H, N> where Equivocation<H, N>: Decode, Equivocation<H, N>: Decode,`

`impl<H, N> Decode for Equivocation<H, N> where Equivocation<AuthorityId, Prevote<H, N>, AuthoritySignature>: Decode, Equivocation<AuthorityId, Prevote<H, N>, AuthoritySignature>: Decode, Equivocation<AuthorityId, Precommit<H, N>, AuthoritySignature>: Decode, Equivocation<AuthorityId, Precommit<H, N>, AuthoritySignature>: Decode,`

`impl<'a> Decode for VersionedAuthorityList<'a>`

`impl Decode for OpaqueKeyOwnershipProof`

`impl Decode for InherentData`

`impl Decode for CheckInherentsResult`

`impl Decode for EcdsaVerifyError`

`impl Decode for KillStorageResult`

`impl<T: Encode + Decode> Decode for Crossing<T> where T: Decode, T: Decode,`

`impl<AccountId, P: PerThing> Decode for Assignment<AccountId, P> where AccountId: Decode, AccountId: Decode, Vec<(AccountId, P)>: Decode, Vec<(AccountId, P)>: Decode,`

`impl<AccountId> Decode for StakedAssignment<AccountId> where AccountId: Decode, AccountId: Decode, Vec<(AccountId, ExtendedBalance)>: Decode, Vec<(AccountId, ExtendedBalance)>: Decode,`

`impl<VoterIndex, TargetIndex, P: PerThing> Decode for IndexAssignment<VoterIndex, TargetIndex, P> where VoterIndex: Decode, VoterIndex: Decode, Vec<(TargetIndex, P)>: Decode, Vec<(TargetIndex, P)>: Decode,`

`impl<AccountId> Decode for Support<AccountId> where Vec<(AccountId, ExtendedBalance)>: Decode, Vec<(AccountId, ExtendedBalance)>: Decode,`

`impl<Header, Extrinsic: MaybeSerialize> Decode for Block<Header, Extrinsic> where Header: Decode, Header: Decode, Vec<Extrinsic>: Decode, Vec<Extrinsic>: Decode,`

`impl<Block> Decode for SignedBlock<Block> where Block: Decode, Block: Decode,`

`impl<Hash> Decode for Digest<Hash> where Vec<DigestItem<Hash>>: Decode, Vec<DigestItem<Hash>>: Decode,`

`impl Decode for ChangesTrieSignal`

`impl<Hash: Decode> Decode for DigestItem<Hash>`

`impl Decode for Era`

`impl<Number: Copy + Into<U256> + TryFrom<U256>, Hash: HashT> Decode for Header<Number, Hash> where Hash::Output: Decode, Hash::Output: Decode, Hash::Output: Decode, Hash::Output: Decode, Hash::Output: Decode, Hash::Output: Decode, Digest<Hash::Output>: Decode, Digest<Hash::Output>: Decode, Number: HasCompact,`

`impl<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra> where Address: Decode, Signature: Decode, Call: Decode, Extra: SignedExtension,`

`impl<AccountId, AccountIndex> Decode for MultiAddress<AccountId, AccountIndex> where AccountId: Decode, AccountId: Decode, AccountIndex: HasCompact,`

`impl Decode for Time`

`impl<B: BlockNumberProvider> Decode for BlockAndTimeDeadline<B> where <B as BlockNumberProvider>::BlockNumber: Decode, <B as BlockNumberProvider>::BlockNumber: Decode,`

`impl Decode for RuntimeString`

`impl Decode for UintAuthorityId`

`impl Decode for TestSignature`

`impl<Xt> Decode for ExtrinsicWrapper<Xt> where Xt: Decode, Xt: Decode,`

`impl<Xt> Decode for Block<Xt> where Vec<Xt>: Decode, Vec<Xt>: Decode,`

`impl<Call, Extra> Decode for TestXt<Call, Extra> where Option<(u64, Extra)>: Decode, Option<(u64, Extra)>: Decode, Call: Decode, Call: Decode,`

`impl Decode for BadOrigin`

`impl Decode for LookupError`

`impl Decode for InvalidTransaction`

`impl Decode for UnknownTransaction`

`impl Decode for TransactionValidityError`

`impl Decode for TransactionSource`

`impl Decode for ValidTransaction`

`impl Decode for Justifications`

`impl Decode for MultiSignature`

`impl Decode for MultiSigner`

`impl Decode for AnySignature`

`impl Decode for DispatchError`

`impl<Info> Decode for DispatchErrorWithPostInfo<Info> where Info: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable, Info: Decode, Info: Decode,`

`impl Decode for TokenError`

`impl Decode for ArithmeticError`

`impl Decode for OpaqueExtrinsic`

`impl Decode for MembershipProof`

`impl<Reporter, Offender> Decode for OffenceDetails<Reporter, Offender> where Offender: Decode, Offender: Decode, Vec<Reporter>: Decode, Vec<Reporter>: Decode,`