pub trait Decode: Sized {
    fn decode<I>(input: &mut I) -> Result<Self, Error>
    where
        I: Input
; fn skip<I>(input: &mut I) -> Result<(), Error>
    where
        I: Input
, { ... } fn encoded_fixed_size() -> Option<usize> { ... } }
Expand description

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

Required Methods§

source

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

Attempt to deserialise the value from input.

Provided Methods§

source

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 provide a specialized implementation.

source

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§

source§

impl Decode for WasmMetadata

source§

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

source§

impl Decode for WasmFields

source§

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

source§

impl Decode for WasmEntryAttributes

source§

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

source§

impl Decode for WasmLevel

source§

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

source§

impl Decode for WasmValuesSet

source§

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

source§

impl Decode for WasmFieldName

source§

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

source§

impl Decode for WasmValue

source§

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

source§

impl Decode for NonZeroU32

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for NonZeroI64

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

impl Decode for NonZeroI16

source§

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

source§

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,

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

impl Decode for i32

source§

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

source§

impl Decode for NonZeroI128

source§

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

source§

impl Decode for f32

source§

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

source§

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,

source§

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

source§

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

source§

impl Decode for NonZeroU64

source§

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

source§

impl Decode for ()

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

impl Decode for i128

source§

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

source§

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

source§

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

source§

impl Decode for i8

source§

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

source§

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

source§

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

source§

impl Decode for bool

source§

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

source§

impl Decode for Bytes

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

impl Decode for u128

source§

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

source§

impl Decode for String

source§

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

source§

impl Decode for NonZeroI8

source§

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

source§

impl Decode for i64

source§

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

source§

impl Decode for NonZeroI32

source§

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

source§

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,

source§

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,

source§

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

source§

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

source§

impl Decode for u64

source§

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

source§

impl Decode for NonZeroU8

source§

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

source§

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,

source§

impl Decode for u8

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

impl Decode for i16

source§

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

source§

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,

source§

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

source§

impl Decode for u16

source§

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

source§

impl Decode for f64

source§

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

source§

impl Decode for u32

source§

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

source§

impl Decode for NonZeroU16

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

impl Decode for NonZeroU128

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

impl Decode for StorageEntryModifier

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeMetadataDeprecated

source§

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

source§

impl Decode for OpaqueMetadata

source§

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

source§

impl Decode for RuntimeMetadataV14

source§

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

source§

impl Decode for RuntimeMetadataPrefixed

source§

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

source§

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

source§

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

source§

impl Decode for StorageHasher

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeMetadata

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

impl Decode for PortableRegistry

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for TypeDefPrimitive

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for OpaqueMetadata

source§

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

source§

impl Decode for LogLevel

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Timestamp

source§

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

source§

impl Decode for CryptoTypePublicPair

source§

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

source§

impl Decode for LogLevelFilter

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for CryptoTypeId

source§

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

source§

impl Decode for OpaquePeerId

source§

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

source§

impl Decode for HttpError

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for LocalizedSignature

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for HttpRequestId

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for KeyTypeId

source§

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

source§

impl Decode for StorageKind

source§

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

source§

impl Decode for OpaqueNetworkState

source§

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

source§

impl Decode for AccountId32

source§

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

source§

impl Decode for HttpRequestStatus

source§

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

source§

impl Decode for DeriveJunction

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for OpaqueMultiaddr

source§

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

§

impl Decode for Value

§

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

§

impl Decode for ReturnValue

§

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

§

impl Decode for StorageData

§

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

§

impl Decode for ChildTrieParentKeyId

§

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

§

impl Decode for StorageKey

§

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

§

impl Decode for U256

§

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

§

impl Decode for U128

§

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

§

impl Decode for H128

§

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

§

impl Decode for U512

§

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

§

impl Decode for H512

§

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

§

impl Decode for H256

§

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

§

impl Decode for H384

§

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

§

impl Decode for H160

§

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

§

impl Decode for H768

§

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

source§

impl Decode for EcdsaVerifyError

source§

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

source§

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

source§

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

§

impl Decode for StorageProof

§

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

§

impl Decode for CompactProof

§

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

source§

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

source§

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

source§

impl Decode for UintAuthorityId

source§

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

source§

impl Decode for RuntimeString

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for MultiSigner

source§

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

source§

impl Decode for Justifications

source§

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

source§

impl Decode for TestSignature

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for OpaqueExtrinsic

source§

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

source§

impl Decode for LookupError

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for DigestItem

source§

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

source§

impl Decode for TokenError

source§

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

source§

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

source§

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

source§

impl Decode for MultiSignature

source§

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

source§

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

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for Digest

source§

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

source§

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

source§

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

source§

impl Decode for AnySignature

source§

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

source§

impl Decode for BadOrigin

source§

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

source§

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

source§

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

source§

impl Decode for Era

source§

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

source§

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

source§

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

source§

impl Decode for Time

source§

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

source§

impl Decode for TransactionalError

source§

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

source§

impl Decode for Perquintill

source§

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

source§

impl Decode for FixedU128

source§

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

source§

impl Decode for Percent

source§

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

source§

impl Decode for FixedI128

source§

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

source§

impl Decode for PerU16

source§

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

source§

impl Decode for ArithmeticError

source§

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

source§

impl Decode for FixedU64

source§

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

source§

impl Decode for BigUint

source§

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

source§

impl Decode for Perbill

source§

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

source§

impl Decode for FixedI64

source§

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

source§

impl Decode for Permill

source§

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

§

impl Decode for Signature

§

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

§

impl Decode for Public

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Public

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Public

§

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

source§

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

source§

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

source§

impl Decode for DisableStrategy

source§

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

§

impl Decode for RuntimeVersion

§

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

Implementors§

source§

impl Decode for DispatchClass

source§

impl Decode for Pays

source§

impl Decode for Never

source§

impl Decode for Void

§

impl Decode for ChildInfo

source§

impl Decode for KillStorageResult

§

impl Decode for StateVersion

source§

impl Decode for ProcessMessageError

source§

impl Decode for frame_support::traits::schedule::LookupError

source§

impl Decode for BalanceStatus

source§

impl Decode for frame_support::pallet_prelude::DispatchError

source§

impl Decode for InvalidTransaction

source§

impl Decode for TransactionSource

source§

impl Decode for TransactionValidityError

source§

impl Decode for UnknownTransaction

source§

impl Decode for DispatchInfo

source§

impl Decode for PostDispatchInfo

source§

impl Decode for CheckInherentsResult

§

impl Decode for MultiRemovalResults

source§

impl Decode for PalletId

source§

impl Decode for CrateVersion

source§

impl Decode for StorageInfo

source§

impl Decode for StorageVersion

§

impl Decode for TrackedStorageKey

source§

impl Decode for WithdrawReasons

source§

impl Decode for OldWeight

source§

impl Decode for RuntimeDbWeight

source§

impl Decode for OptionBool

source§

impl Decode for Compact<u8>

source§

impl Decode for Compact<u16>

source§

impl Decode for Compact<u32>

source§

impl Decode for Compact<u64>

source§

impl Decode for Compact<u128>

source§

impl Decode for Compact<()>

source§

impl Decode for InherentData

source§

impl Decode for ValidTransaction

source§

impl Decode for Weight

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Bounded<T>where
    PhantomData<T>: Decode,

source§

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

source§

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

source§

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

source§

impl<T> Decode for PhantomData<T>

source§

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

source§

impl<T, Hash> Decode for MaybeHashed<T, Hash>where
    T: Decode,
    Hash: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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