Trait frame_support::dispatch::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> { ... }
}

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

impl Decode for WasmFields

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

impl Decode for WasmValuesSet

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

impl Decode for WasmLevel

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

impl Decode for WasmEntryAttributes

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

impl Decode for WasmFieldName

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

impl Decode for WasmMetadata

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

impl Decode for WasmValue

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

impl Decode for NonZeroI32

pub fn decode<I>(input: &mut I) -> Result<NonZeroI32, 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 Decode for u16

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<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,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    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<(B0, C0, D0, E0, F0, G0, 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 Decode for i128

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i128, 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 Decode for String

pub fn decode<I>(input: &mut I) -> Result<String, 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 Decode for bool

pub fn decode<I>(input: &mut I) -> Result<bool, 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
    F0: Decode,
    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<(F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

impl Decode for Compact<u128>

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

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

pub fn decode<I>(input: &mut I) -> Result<VecDeque<T, Global>, 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 Decode for NonZeroU32

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

impl Decode for u64

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u64, 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<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 i64

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i64, 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 u8

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u8, Error> where
    I: 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 Decode for i8

pub const TYPE_INFO: TypeInfo

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

impl Decode for NonZeroU64

pub fn decode<I>(input: &mut I) -> Result<NonZeroU64, Error> where
    I: 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 Decode for NonZeroI8

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

impl Decode for Compact<u32>

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

impl Decode for Compact<()>

pub fn decode<I>(_input: &mut I) -> Result<Compact<()>, Error> where
    I: 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<'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 OptionBool

pub fn decode<I>(input: &mut I) -> Result<OptionBool, Error> where
    I: 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
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    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<(C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: 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<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 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<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 ()

pub fn decode<I>(&mut I) -> Result<(), 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<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 NonZeroU16

pub fn decode<I>(input: &mut I) -> Result<NonZeroU16, 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
    A0: Decode,
    B0: Decode,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    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<(A0, B0, C0, D0, E0, 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 NonZeroI128

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

impl Decode for NonZeroI64

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

impl Decode for Compact<u16>

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

impl Decode for NonZeroU128

pub fn decode<I>(input: &mut I) -> Result<NonZeroU128, 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 Decode for NonZeroU8

pub fn decode<I>(input: &mut I) -> Result<NonZeroU8, Error> where
    I: 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<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 Duration

pub fn decode<I>(input: &mut I) -> Result<Duration, Error> where
    I: 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 i32

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i32, Error> where
    I: 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 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 HttpRequestStatus

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

impl Decode for HttpError

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

impl Decode for Public

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

impl Decode for Duration

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

impl Decode for HttpRequestId

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

impl Decode for OpaqueMetadata

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

impl Decode for CryptoTypeId

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

impl Decode for Signature

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

impl Decode for HostError

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

impl Decode for EnvironmentDefinition

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

impl Decode for Entry

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

impl Decode for LogLevel

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

impl Decode for Signature

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

impl Decode for Public

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

impl Decode for StorageKind

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

impl Decode for OpaqueNetworkState

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

impl Decode for Signature

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

impl Decode for KeyTypeId

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

impl Decode for LocalizedSignature

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

impl Decode for DeriveJunction

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

impl Decode for Public

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

impl Decode for ExternEntity

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

impl Decode for OpaquePeerId

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

impl Decode for ChangesTrieConfiguration

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

impl Decode for AccountId32

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

impl Decode for CryptoTypePublicPair

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

impl Decode for NeverNativeValue

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

impl Decode for Timestamp

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

impl Decode for OpaqueMultiaddr

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

impl Decode for Value

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

impl Decode for ReturnValue

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

impl Decode for TrackedStorageKey

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

impl Decode for H512

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

impl Decode for U128

pub fn decode<I>(input: &mut I) -> Result<U128, 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 U256

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

impl Decode for H256

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

impl Decode for H128

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

impl Decode for StorageProof

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

impl Decode for EcdsaVerifyError

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

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

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

impl Decode for RuntimeMetadataDeprecated

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

impl Decode for RuntimeMetadataV12

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

impl Decode for BadOrigin

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

impl Decode for ChangesTrieSignal

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

impl Decode for LookupError

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

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

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

impl Decode for Time

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

impl Decode for MultiSignature

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

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

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

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

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

impl Decode for OpaqueExtrinsic

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

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

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

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

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

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

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

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

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

impl Decode for UintAuthorityId

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

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

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

impl Decode for MultiSigner

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

impl Decode for RuntimeString

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

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

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

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

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

impl Decode for TestSignature

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

impl Decode for StoredMapError

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

impl<Hashing> Decode for RandomNumberGenerator<Hashing> where
    Hashing: Hash,
    <Hashing as Hash>::Output: Decode, 

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

impl Decode for ModuleId

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

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

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

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

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

impl Decode for Era

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

impl Decode for AnySignature

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

impl Decode for Signature

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

impl Decode for Signature

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

impl Decode for Public

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

impl Decode for Public

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

impl Decode for Public

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

impl Decode for Signature

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

impl Decode for Perbill

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

impl Decode for FixedI64

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

impl Decode for PerU16

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

impl Decode for Permill

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

impl Decode for Percent

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

impl Decode for Perquintill

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

impl Decode for FixedI128

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

impl Decode for FixedU128

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

impl Decode for Error

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

impl Decode for CheckInherentsResult

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

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

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

Implementors

impl Decode for Void

impl Decode for RuntimeMetadata

impl Decode for StorageEntryModifier

impl Decode for StorageEntryType

impl Decode for StorageHasher

impl Decode for DispatchError

impl Decode for InvalidTransaction

impl Decode for TransactionSource

impl Decode for TransactionValidityError

impl Decode for UnknownTransaction

impl Decode for BalanceStatus

impl Decode for DispatchClass

impl Decode for Pays

impl Decode for EventMetadata

impl Decode for OuterEventMetadata

impl Decode for ExtrinsicMetadata

impl Decode for ModuleMetadata

impl Decode for RuntimeMetadataPrefixed

impl Decode for StorageEntryMetadata

impl Decode for StorageMetadata

impl Decode for InherentData

impl Decode for ValidTransaction

impl Decode for PalletVersion

impl Decode for WithdrawReasons

impl Decode for DispatchInfo

impl Decode for PostDispatchInfo

impl Decode for RuntimeDbWeight

impl Decode for ErrorMetadata

impl Decode for FunctionArgumentMetadata

impl Decode for FunctionMetadata

impl Decode for ModuleConstantMetadata

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

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

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

impl<T> Decode for PhantomData<T>

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

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

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

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

impl Decode for SessionKeys

impl Decode for Event

impl Decode for OriginCaller

impl Decode for Call

impl Decode for Characters

impl Decode for ForWhat

impl<T, A, B> Decode for AnagolayRecord<T, A, B> where
    T: Decode,
    T: Decode,
    A: Decode,
    A: Decode,
    B: Decode,
    B: Decode, 

impl<T: AnagolayStructureData, U: AnagolayStructureExtra> Decode for AnagolayStructure<T, U> where
    T: Decode,
    T: Decode,
    Option<U>: Decode,
    Option<U>: Decode, 

impl<T: ArtifactType> Decode for AnagolayArtifactStructure<T> where
    T: Decode,
    T: Decode, 

impl Decode for AnagolayVersionExtra

impl<T: ArtifactType> Decode for AnagolayVersionData<T> where
    Vec<AnagolayArtifactStructure<T>>: Decode,
    Vec<AnagolayArtifactStructure<T>>: Decode, 

impl Decode for WasmArtifactSubType

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

impl<H, N> Decode for State<H, N> where
    Option<(H, N)>: Decode,
    Option<(H, N)>: Decode,
    Option<(H, N)>: Decode,
    Option<(H, N)>: Decode,
    Option<(H, N)>: Decode,
    Option<(H, N)>: Decode, 

impl<H, N> Decode for Prevote<H, N> where
    H: Decode,
    H: Decode,
    N: Decode,
    N: Decode, 

impl<H, N> Decode for Precommit<H, N> where
    H: Decode,
    H: Decode,
    N: Decode,
    N: Decode, 

impl<H, N> Decode for PrimaryPropose<H, N> where
    H: Decode,
    H: Decode,
    N: Decode,
    N: Decode, 

impl<Id, V, S> Decode for Equivocation<Id, V, S> where
    Id: Decode,
    Id: Decode,
    V: Decode,
    S: Decode,
    (V, S): Decode,
    V: Decode,
    S: Decode,
    (V, S): Decode, 

impl<H, N> Decode for Message<H, N> where
    Prevote<H, N>: Decode,
    Prevote<H, N>: Decode,
    Precommit<H, N>: Decode,
    Precommit<H, N>: Decode,
    PrimaryPropose<H, N>: Decode,
    PrimaryPropose<H, N>: Decode, 

impl<H, N, S, Id> Decode for SignedMessage<H, N, S, Id> where
    Message<H, N>: Decode,
    Message<H, N>: Decode,
    S: Decode,
    S: Decode,
    Id: Decode,
    Id: Decode, 

impl<H, N, S, Id> Decode for Commit<H, N, S, Id> where
    H: Decode,
    H: Decode,
    N: Decode,
    N: Decode,
    Vec<SignedPrecommit<H, N, S, Id>>: Decode,
    Vec<SignedPrecommit<H, N, S, Id>>: Decode, 

impl<H, N, S, Id> Decode for SignedPrevote<H, N, S, Id> where
    Prevote<H, N>: Decode,
    Prevote<H, N>: Decode,
    S: Decode,
    S: Decode,
    Id: Decode,
    Id: Decode, 

impl<H, N, S, Id> Decode for SignedPrecommit<H, N, S, Id> where
    Precommit<H, N>: Decode,
    Precommit<H, N>: Decode,
    S: Decode,
    S: Decode,
    Id: Decode,
    Id: Decode, 

impl<H, N, S, Id> Decode for CompactCommit<H, N, S, Id> where
    H: Decode,
    H: Decode,
    N: Decode,
    N: Decode,
    Vec<Precommit<H, N>>: Decode,
    Vec<Precommit<H, N>>: Decode,
    MultiAuthData<S, Id>: Decode,
    MultiAuthData<S, Id>: Decode, 

impl<H, N, S, Id> Decode for CatchUp<H, N, S, Id> where
    Vec<SignedPrevote<H, N, S, Id>>: Decode,
    Vec<SignedPrevote<H, N, S, Id>>: Decode,
    Vec<SignedPrecommit<H, N, S, Id>>: Decode,
    Vec<SignedPrecommit<H, N, S, Id>>: Decode,
    H: Decode,
    H: Decode,
    N: Decode,
    N: Decode, 

impl<H, N, S, Id> Decode for HistoricalVotes<H, N, S, Id> where
    Vec<SignedMessage<H, N, S, Id>>: Decode,
    Vec<SignedMessage<H, N, S, Id>>: Decode, 

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 BenchmarkResults

impl Decode for BenchmarkConfig

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 RuntimeMetadataV12

impl Decode for ModuleMetadata

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, 

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 OperationData

impl Decode for OperationExtra

impl Decode for OperationArtifactType

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

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

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

impl<T: Config> Decode for Call<T> where
    Vec<T::Header>: Decode,
    Vec<T::Header>: Decode, 

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> 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,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    T::Balance: HasCompact,
    T::Balance: HasCompact,
    T::Balance: HasCompact,
    T::Balance: HasCompact,
    T::Balance: HasCompact, 

impl Decode for Reasons

impl<Balance> Decode for BalanceLock<Balance> where
    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 Decode for GrandpaTimeSlot

impl<N> Decode for OldStoredPendingChange<N> where
    N: Decode,
    N: Decode,
    N: Decode,
    N: Decode, 

impl<N: Decode> Decode for StoredPendingChange<N>

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 Event

impl<T: Config> Decode for Call<T> where
    EquivocationProof<T::Hash, T::BlockNumber>: Decode,
    EquivocationProof<T::Hash, T::BlockNumber>: Decode,
    T::KeyOwnerProof: Decode,
    T::KeyOwnerProof: Decode,
    EquivocationProof<T::Hash, T::BlockNumber>: Decode,
    EquivocationProof<T::Hash, T::BlockNumber>: Decode,
    T::KeyOwnerProof: Decode,
    T::KeyOwnerProof: Decode,
    T::BlockNumber: Decode,
    T::BlockNumber: Decode,
    T::BlockNumber: Decode,
    T::BlockNumber: Decode, 

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<T: Config> Decode for Call<T> where
    Box<<T as Config>::Call>: Decode,
    Box<<T as Config>::Call>: Decode,
    Box<<T as Config>::Call>: Decode,
    Box<<T as Config>::Call>: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    Box<<T as Config>::Call>: Decode,
    Box<<T as Config>::Call>: Decode, 

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

impl<T: Config> Decode for Call<T> where
    T::Moment: 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 Event

impl<T: Config> Decode for Call<T> where
    Vec<<T as Config>::Call>: Decode,
    Vec<<T as Config>::Call>: Decode,
    Box<<T as Config>::Call>: Decode,
    Box<<T as Config>::Call>: Decode,
    Vec<<T as Config>::Call>: Decode,
    Vec<<T as Config>::Call>: Decode, 

impl Decode for U128

impl Decode for U256

impl Decode for U512

impl Decode for H128

impl Decode for H160

impl Decode for H256

impl Decode for H512

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<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<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 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 Percent

impl Decode for PerU16

impl Decode for Permill

impl Decode for Perbill

impl Decode for Perquintill

impl Decode for FixedI64

impl Decode for FixedI128

impl Decode for FixedU128

impl Decode for InherentError

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

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 Public

impl Decode for Signature

impl Decode for LocalizedSignature

impl Decode for Public

impl Decode for Signature

impl Decode for Public

impl Decode for Signature

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 ChangesTrieConfiguration

impl Decode for OpaqueMetadata

impl Decode for OpaquePeerId

impl Decode for NeverNativeValue

impl Decode for LogLevel

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 Error

impl Decode for InherentData

impl Decode for CheckInherentsResult

impl Decode for EcdsaVerifyError

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

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

impl Decode for Era

impl<Number, Hash> Decode for Header<Number, Hash> where
    Number: HasCompact + Copy + Into<U256> + TryFrom<U256>,
    Hash: HashT,
    Hash::Output: 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 Time

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

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 StoredMapError

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<Hashing: Hash> Decode for RandomNumberGenerator<Hashing> where
    Hashing::Output: Decode,
    Hashing::Output: Decode, 

impl Decode for RuntimeString

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

impl Decode for ModuleId

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 OpaqueExtrinsic

impl Decode for MembershipProof

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

impl Decode for TrackedStorageKey

impl Decode for InherentError

impl Decode for WasmLevel

impl Decode for WasmValue

impl Decode for WasmFieldName

impl Decode for WasmFields

impl Decode for WasmValuesSet

impl Decode for WasmMetadata

impl Decode for WasmEntryAttributes

impl Decode for StorageProof

impl Decode for RuntimeVersion

impl Decode for Value

impl Decode for ReturnValue

impl Decode for OperationVersionReference

impl Decode for WorkflowSegment

impl Decode for WorkflowData

impl Decode for WorkflowExtra

impl Decode for WorkflowArtifactType

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

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