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 WasmMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmMetadata, 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 WasmValuesSet

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValuesSet, 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 WasmValue

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValue, 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 WasmFields

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

impl Decode for i8

pub const TYPE_INFO: TypeInfo

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

pub fn decode<I>(input: &mut I) -> Result<Compact<u16>, 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<T> Decode for BTreeSet<T> where
    T: Decode + Ord, 

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

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

impl Decode for NonZeroI8

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

pub const TYPE_INFO: TypeInfo

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

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

impl Decode for NonZeroU16

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

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

impl Decode for NonZeroI64

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

pub const TYPE_INFO: TypeInfo

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

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

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

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

pub fn decode<I>(&mut I) -> Result<(), 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<T> Decode for RangeInclusive<T> where
    T: Decode, 

pub fn decode<I>(input: &mut I) -> Result<RangeInclusive<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<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<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 NonZeroI128

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

impl Decode for Compact<u128>

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

pub const TYPE_INFO: TypeInfo

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

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

pub const TYPE_INFO: TypeInfo

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

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

impl Decode for NonZeroU64

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

impl Decode for bool

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

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

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

pub const TYPE_INFO: TypeInfo

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

impl Decode for String

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

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

impl Decode for NonZeroU32

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

impl<T> Decode for PalletEventMetadata<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for StorageEntryType<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for PalletStorageMetadata<T> where
    T: Form,
    <T as Form>::String: Decode,
    Vec<StorageEntryMetadata<T>, Global>: Decode, 

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

impl<T> Decode for PalletCallMetadata<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for PalletMetadata<T> where
    T: Form,
    <T as Form>::String: Decode,
    Option<PalletStorageMetadata<T>>: Decode,
    Option<PalletCallMetadata<T>>: Decode,
    Option<PalletEventMetadata<T>>: Decode,
    Vec<PalletConstantMetadata<T>, Global>: Decode,
    Option<PalletErrorMetadata<T>>: Decode, 

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

impl<T> Decode for PalletConstantMetadata<T> where
    T: Form,
    <T as Form>::String: Decode,
    <T as Form>::Type: Decode,
    Vec<<T as Form>::String, Global>: Decode, 

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

impl<T> Decode for PalletErrorMetadata<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl Decode for StorageHasher

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

impl<T> Decode for SignedExtensionMetadata<T> where
    T: Form,
    <T as Form>::String: Decode,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for ExtrinsicMetadata<T> where
    T: Form,
    <T as Form>::Type: Decode,
    Vec<SignedExtensionMetadata<T>, Global>: Decode, 

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

impl Decode for StorageEntryModifier

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

impl Decode for RuntimeMetadata

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

impl<T> Decode for StorageEntryMetadata<T> where
    T: Form,
    <T as Form>::String: Decode,
    StorageEntryType<T>: Decode,
    Vec<<T as Form>::String, Global>: Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryMetadata<T>, 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 RuntimeMetadataPrefixed

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

impl Decode for RuntimeMetadataV14

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

impl Decode for RuntimeMetadataDeprecated

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

impl Decode for TypeDefPrimitive

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

impl<T> Decode for TypeDef<T> where
    T: Form,
    TypeDefComposite<T>: Decode,
    TypeDefVariant<T>: Decode,
    TypeDefSequence<T>: Decode,
    TypeDefArray<T>: Decode,
    TypeDefTuple<T>: Decode,
    TypeDefCompact<T>: Decode,
    TypeDefBitSequence<T>: Decode, 

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

impl<T> Decode for TypeDefSequence<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for TypeDefVariant<T> where
    T: Form,
    Vec<Variant<T>, Global>: Decode, 

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

impl<T> Decode for UntrackedSymbol<T> where
    PhantomData<fn() -> T>: Decode, 

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

impl<T> Decode for Type<T> where
    T: Form,
    Path<T>: Decode,
    Vec<TypeParameter<T>, Global>: Decode,
    TypeDef<T>: Decode,
    Vec<<T as Form>::String, Global>: Decode, 

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

impl<T> Decode for Path<T> where
    T: Form,
    Vec<<T as Form>::String, Global>: Decode, 

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

impl Decode for PortableRegistry

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

impl<T> Decode for TypeDefCompact<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for Field<T> where
    T: Form,
    Option<<T as Form>::String>: Decode,
    <T as Form>::Type: Decode,
    Vec<<T as Form>::String, Global>: Decode, 

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

impl<T> Decode for Variant<T> where
    T: Form,
    <T as Form>::String: Decode,
    Vec<Field<T>, Global>: Decode,
    Vec<<T as Form>::String, Global>: Decode, 

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

impl<T> Decode for TypeParameter<T> where
    T: Form,
    <T as Form>::String: Decode,
    Option<<T as Form>::Type>: Decode, 

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

impl<T> Decode for TypeDefComposite<T> where
    T: Form,
    Vec<Field<T>, Global>: Decode, 

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

impl<T> Decode for TypeDefTuple<T> where
    T: Form,
    Vec<<T as Form>::Type, Global>: Decode, 

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

impl<T> Decode for TypeDefBitSequence<T> where
    T: Form,
    <T as Form>::Type: Decode, 

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

impl<T> Decode for TypeDefArray<T> where
    T: Form,
    <T as Form>::Type: Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TypeDefArray<T>, 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 EnvironmentDefinition

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

impl Decode for NeverNativeValue

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

impl Decode for Signature

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

impl Decode for HttpRequestStatus

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpRequestStatus, 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 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 DeriveJunction

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

impl Decode for LogLevelFilter

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LogLevelFilter, 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 Entry

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Entry, 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 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 CryptoTypeId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CryptoTypeId, 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 Public

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

impl Decode for Timestamp

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Timestamp, 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 LocalizedSignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LocalizedSignature, 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 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 Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, 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 OpaqueMultiaddr

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueMultiaddr, 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 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 StorageKey

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageKey, 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 StorageData

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

impl Decode for H512

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

impl Decode for U256

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

impl Decode for H128

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

impl Decode for U128

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

impl Decode for H256

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

impl Decode for H160

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

impl Decode for U512

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

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

impl Decode for StorageProof

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

impl Decode for CompactProof

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

impl Decode for ArithmeticError

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

impl Decode for TestSignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TestSignature, 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 Decode for OpaqueExtrinsic

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueExtrinsic, Error> where
    __CodecInputEdqy: 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 Decode for LookupError

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

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

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

impl Decode for TokenError

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

impl Decode for DigestItem

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

impl Decode for Justifications

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

impl Decode for MultiSigner

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiSigner, 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 MultiSignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiSignature, 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 AnySignature

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

impl Decode for Digest

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Digest, 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 UintAuthorityId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<UintAuthorityId, 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 Decode for Era

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

impl<Block> Decode for BlockId<Block> where
    Block: Block,
    <Block as Block>::Hash: Decode,
    <<Block as Block>::Header as Header>::Number: Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BlockId<Block>, 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 BadOrigin

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

impl Decode for RuntimeString

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

impl Decode for Time

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Time, 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<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 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 FixedI128

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

impl Decode for Percent

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

impl Decode for FixedU128

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

impl Decode for Perquintill

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

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

impl Decode for PerU16

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

impl Decode for BigUint

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

impl Decode for Permill

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

impl Decode for DisableStrategy

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<DisableStrategy, 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 DispatchError

impl Decode for InvalidTransaction

impl Decode for TransactionSource

impl Decode for TransactionValidityError

impl Decode for UnknownTransaction

impl Decode for KillStorageResult

impl Decode for BalanceStatus

impl Decode for DispatchClass

impl Decode for Pays

impl Decode for CheckInherentsResult

impl Decode for InherentData

impl Decode for ValidTransaction

impl Decode for PalletId

impl Decode for CrateVersion

impl Decode for StorageInfo

impl Decode for StorageVersion

impl Decode for WithdrawReasons

impl Decode for DispatchInfo

impl Decode for PostDispatchInfo

impl Decode for RuntimeDbWeight

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<K, V, S> Decode for BoundedBTreeMap<K, V, S> where
    K: Decode + Ord,
    V: Decode,
    S: Get<u32>, 

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

impl<T: Decode> Decode for WrapperKeepOpaque<T>

impl<T: Decode> Decode for WrapperOpaque<T>

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

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

impl Decode for BenchmarkParameter

impl Decode for BenchmarkBatch

impl Decode for BenchmarkBatchSplitResults

impl Decode for BenchmarkResult

impl Decode for BenchmarkConfig

impl Decode for BenchmarkList

impl Decode for BenchmarkMetadata

impl Decode for RuntimeMetadataV14

impl<T: Form> Decode for ExtrinsicMetadata<T> where
    T::Type: Decode,
    T::Type: Decode,
    Vec<SignedExtensionMetadata<T>>: Decode,
    Vec<SignedExtensionMetadata<T>>: Decode, 

impl<T: Form> Decode for SignedExtensionMetadata<T> where
    T::String: Decode,
    T::String: Decode,
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for PalletMetadata<T> where
    T::String: Decode,
    T::String: Decode,
    Option<PalletStorageMetadata<T>>: Decode,
    Option<PalletStorageMetadata<T>>: Decode,
    Option<PalletCallMetadata<T>>: Decode,
    Option<PalletCallMetadata<T>>: Decode,
    Option<PalletEventMetadata<T>>: Decode,
    Option<PalletEventMetadata<T>>: Decode,
    Vec<PalletConstantMetadata<T>>: Decode,
    Vec<PalletConstantMetadata<T>>: Decode,
    Option<PalletErrorMetadata<T>>: Decode,
    Option<PalletErrorMetadata<T>>: Decode, 

impl<T: Form> Decode for PalletStorageMetadata<T> where
    T::String: Decode,
    T::String: Decode,
    Vec<StorageEntryMetadata<T>>: Decode,
    Vec<StorageEntryMetadata<T>>: Decode, 

impl<T: Form> Decode for StorageEntryMetadata<T> where
    T::String: Decode,
    T::String: Decode,
    StorageEntryType<T>: Decode,
    StorageEntryType<T>: Decode,
    Vec<T::String>: Decode,
    Vec<T::String>: Decode, 

impl Decode for StorageEntryModifier

impl Decode for StorageHasher

impl<T: Form> Decode for StorageEntryType<T> where
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for PalletCallMetadata<T> where
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for PalletEventMetadata<T> where
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for PalletConstantMetadata<T> where
    T::String: Decode,
    T::String: Decode,
    T::Type: Decode,
    T::Type: Decode,
    Vec<T::String>: Decode,
    Vec<T::String>: Decode, 

impl<T: Form> Decode for PalletErrorMetadata<T> where
    T::Type: Decode,
    T::Type: Decode, 

impl Decode for RuntimeMetadataPrefixed

impl Decode for RuntimeMetadata

impl Decode for OpaqueMetadata

impl Decode for RuntimeMetadataDeprecated

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<T: Config> Decode for Event<T> where
    <T as Config>::AccountId: Decode,
    <T as Config>::AccountId: Decode, 

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

impl<T: Config> Decode for Event<T> where
    T::AccountId: Decode,
    T::AccountId: Decode,
    T::Hash: Decode,
    T::Hash: 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::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::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<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::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::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<T: Config> Decode for Event<T> where
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode, 

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

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

impl<Balance, BlockNumber> Decode for EscrowedAmount<Balance, BlockNumber> where
    Balance: Decode,
    Balance: Decode,
    BlockNumber: Decode,
    BlockNumber: 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<T: Config> Decode for Event<T> where
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode,
    T::Hash: Decode, 

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

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

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

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

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

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

impl<T: Config> Decode for Event<T> where
    T::Hash: Decode,
    T::Hash: Decode,
    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::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::AccountId: Decode,
    T::AccountId: Decode,
    T::Hash: Decode,
    T::Hash: Decode, 

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

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

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<T: Config> Decode for Call<T>

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

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

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

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<T> Decode for UntrackedSymbol<T> where
    PhantomData<fn() -> T>: Decode,
    PhantomData<fn() -> T>: Decode, 

impl Decode for PortableRegistry

impl<T: Form> Decode for TypeDefComposite<T> where
    Vec<Field<T>>: Decode,
    Vec<Field<T>>: Decode, 

impl<T: Form> Decode for Field<T> where
    Option<T::String>: Decode,
    Option<T::String>: Decode,
    T::Type: Decode,
    T::Type: Decode,
    Option<T::String>: Decode,
    Option<T::String>: Decode,
    Vec<T::String>: Decode,
    Vec<T::String>: Decode, 

impl<T: Form> Decode for Path<T> where
    Vec<T::String>: Decode,
    Vec<T::String>: Decode, 

impl<T: Form> Decode for TypeDefVariant<T> where
    Vec<Variant<T>>: Decode,
    Vec<Variant<T>>: Decode, 

impl<T: Form> Decode for Variant<T> where
    T::String: Decode,
    T::String: Decode,
    Vec<Field<T>>: Decode,
    Vec<Field<T>>: Decode,
    Vec<T::String>: Decode,
    Vec<T::String>: Decode, 

impl<T: Form> Decode for Type<T> where
    Path<T>: Decode,
    Path<T>: Decode,
    Vec<TypeParameter<T>>: Decode,
    Vec<TypeParameter<T>>: Decode,
    TypeDef<T>: Decode,
    TypeDef<T>: Decode,
    Vec<T::String>: Decode,
    Vec<T::String>: Decode, 

impl<T: Form> Decode for TypeParameter<T> where
    T::String: Decode,
    T::String: Decode,
    Option<T::Type>: Decode,
    Option<T::Type>: Decode, 

impl<T: Form> Decode for TypeDef<T> where
    TypeDefComposite<T>: Decode,
    TypeDefComposite<T>: Decode,
    TypeDefVariant<T>: Decode,
    TypeDefVariant<T>: Decode,
    TypeDefSequence<T>: Decode,
    TypeDefSequence<T>: Decode,
    TypeDefArray<T>: Decode,
    TypeDefArray<T>: Decode,
    TypeDefTuple<T>: Decode,
    TypeDefTuple<T>: Decode,
    TypeDefCompact<T>: Decode,
    TypeDefCompact<T>: Decode,
    TypeDefBitSequence<T>: Decode,
    TypeDefBitSequence<T>: Decode, 

impl Decode for TypeDefPrimitive

impl<T: Form> Decode for TypeDefArray<T> where
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for TypeDefTuple<T> where
    Vec<T::Type>: Decode,
    Vec<T::Type>: Decode, 

impl<T: Form> Decode for TypeDefSequence<T> where
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for TypeDefCompact<T> where
    T::Type: Decode,
    T::Type: Decode, 

impl<T: Form> Decode for TypeDefBitSequence<T> where
    T::Type: Decode,
    T::Type: Decode,
    T::Type: Decode,
    T::Type: 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 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 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 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<Block: BlockT> Decode for BlockId<Block> where
    Block::Hash: Decode,
    Block::Hash: Decode,
    NumberFor<Block>: Decode,
    NumberFor<Block>: 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 Decode for Digest

impl Decode for DigestItem

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,
    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 DisableStrategy

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

impl Decode for StorageKey

impl Decode for TrackedStorageKey

impl Decode for StorageData

impl Decode for Timestamp

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 CompactProof

impl Decode for RuntimeVersion

impl Decode for Value

impl Decode for ReturnValue

impl Decode for ChangesInInventories

impl Decode for Cogs

impl Decode for _0002_

impl Decode for PropertyPlantEquipment

impl Decode for IntangibleAssetList

impl Decode for _0003_

impl Decode for _0004_

impl Decode for _0005_

impl Decode for _0006_

impl Decode for _0007_

impl Decode for _0008_

impl Decode for _0009_

impl Decode for _0010_

impl Decode for _0011_

impl Decode for _0012_

impl Decode for _0013_

impl Decode for _0014_

impl Decode for _0015_

impl Decode for _0016_

impl Decode for _0017_

impl Decode for _0018_

impl Decode for _0019_

impl Decode for _0020_

impl Decode for _0021_

impl Decode for _0022_

impl Decode for _0023_

impl Decode for _0024_

impl Decode for _0025_

impl Decode for _0026_

impl Decode for _0027_

impl Decode for _0028_

impl Decode for _0029_

impl Decode for NonCapitalised

impl Decode for RecoveredExpenses

impl Decode for _0030_

impl Decode for _0031_

impl Decode for _0032_

impl Decode for _0033_

impl Decode for _0034_

impl Decode for _0035_

impl Decode for _0036_

impl Decode for _0038_

impl Decode for _1001_

impl Decode for SocialSecurity

impl Decode for _2001_

impl Decode for _2002_

impl Decode for _2003_

impl Decode for _2004_

impl Decode for _2005_

impl Decode for _3001_

impl Decode for AccruedRevenuesReceivables

impl Decode for Inventory

impl Decode for CurrentAssets

impl Decode for Coins

impl Decode for Fungibility

impl Decode for Tokens

impl Decode for CurrentAssetsCrypto

impl Decode for FixedAssets

impl Decode for IntagibleAssets

impl Decode for OtherReceivables

impl Decode for InvestmentIn

impl Decode for NonCurrentAssets

impl Decode for Provisions

impl Decode for CurrentLiabilities

impl Decode for Parties

impl Decode for Derivatives

impl Decode for NonCurrentLiabilities

impl Decode for ShareholdersEquity

impl Decode for OtherEquity

impl Decode for CapitalStock

impl Decode for _3003_

impl Decode for OtherReserves

impl Decode for RetainedEarnings

impl Decode for Sales

impl Decode for _1002_

impl Decode for OtherIncome

impl Decode for OtherOperatingIncome

impl Decode for OtherComprehensiveIncome

impl Decode for OperatingExpenses

impl Decode for OtherOperatingExpenses

impl Decode for PersonnelCosts

impl Decode for FinanceCosts

impl Decode for ControlAccounts

impl Decode for A

impl Decode for L

impl Decode for E

impl Decode for I

impl Decode for X

impl Decode for P

impl Decode for B

impl Decode for Ledger

impl Decode for Indicator

impl<AccountId, Hash, BlockNumber> Decode for Record<AccountId, Hash, BlockNumber> where
    AccountId: Decode,
    AccountId: Decode,
    AccountId: Decode,
    AccountId: Decode,
    Hash: Decode,
    Hash: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode, 

impl Decode for Reason

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

impl Decode for ApprovalStatus

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

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

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

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

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

impl Decode for LockStatus

impl<AccountId, ProjectStatus> Decode for DeletedProject<AccountId, ProjectStatus> where
    AccountId: Decode,
    AccountId: Decode,
    AccountId: Decode,
    AccountId: Decode,
    ProjectStatus: Decode,
    ProjectStatus: Decode, 

impl Decode for StatusOfTimeRecord

impl Decode for ReasonCodeStruct

impl Decode for BannedStruct

impl<AccountId, ReferenceHash, NumberOfBlocks, LockStatus, StatusOfTimeRecord, ReasonCodeStruct, PostingPeriod, StartOrEndBlockNumber, NumberOfBreaks> Decode for Timekeeper<AccountId, ReferenceHash, NumberOfBlocks, LockStatus, StatusOfTimeRecord, ReasonCodeStruct, PostingPeriod, StartOrEndBlockNumber, NumberOfBreaks> where
    AccountId: Decode,
    AccountId: Decode,
    ReferenceHash: Decode,
    ReferenceHash: Decode,
    NumberOfBlocks: Decode,
    NumberOfBlocks: Decode,
    LockStatus: Decode,
    LockStatus: Decode,
    ReasonCodeStruct: Decode,
    ReasonCodeStruct: Decode,
    StatusOfTimeRecord: Decode,
    StatusOfTimeRecord: Decode,
    ReasonCodeStruct: Decode,
    ReasonCodeStruct: Decode,
    PostingPeriod: Decode,
    PostingPeriod: Decode,
    StartOrEndBlockNumber: Decode,
    StartOrEndBlockNumber: Decode,
    StartOrEndBlockNumber: Decode,
    StartOrEndBlockNumber: Decode,
    NumberOfBreaks: Decode,
    NumberOfBreaks: Decode, 

impl Decode for RecordType

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