Trait pallet_roles::Decode

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> { ... }
}

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 provide 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 BalanceStatus

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

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

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

impl Decode for RuntimeDbWeight

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

impl Decode for Select

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

impl Decode for PostDispatchInfo

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

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

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

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

impl Decode for StorageInfo

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

impl Decode for CrateVersion

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

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

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

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

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

impl Decode for Never

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

impl Decode for DispatchInfo

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

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

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

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

impl Decode for LookupError

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

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

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

impl Decode for WasmFieldName

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

impl Decode for WasmValue

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

impl Decode for WasmFields

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

impl Decode for WasmEntryAttributes

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

impl Decode for WasmLevel

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

impl Decode for WasmValuesSet

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

impl Decode for WasmMetadata

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

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

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

impl Decode for String

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

impl Decode for f32

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

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

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

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

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

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

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

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

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

impl Decode for i128

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

impl Decode for Duration

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

impl Decode for NonZeroU64

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

impl Decode for ()

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

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

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<R0> Decode for (R0,)where
    R0: Decode,

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

impl Decode for f64

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

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

impl Decode for i16

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

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

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

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

fn decode<INPUT>(input: &mut INPUT) -> Result<(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,

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

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

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

impl Decode for i8

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

impl Decode for NonZeroI64

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

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

impl Decode for NonZeroU16

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

fn decode<INPUT>(input: &mut INPUT) -> Result<(N0, O0, P0, Q0, R0), Error>where
    INPUT: 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,

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

impl Decode for NonZeroI16

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

impl Decode for Bytes

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

impl Decode for u16

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

impl Decode for NonZeroU32

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

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<P0, Q0, R0> Decode for (P0, Q0, R0)where
    P0: Decode,
    Q0: Decode,
    R0: Decode,

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

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

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

impl Decode for u128

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

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

impl Decode for i64

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

impl Decode for NonZeroI128

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

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

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

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

impl Decode for u64

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

impl Decode for u32

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

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

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

impl Decode for NonZeroU128

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

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

fn decode<I>(input: &mut I) -> Result<[T; N], 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,

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

impl Decode for i32

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

impl Decode for bool

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

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

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

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 NonZeroI8

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

impl Decode for NonZeroI32

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

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

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

impl Decode for NonZeroU8

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

impl Decode for u8

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

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

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

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

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

impl Decode for RuntimeMetadata

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

impl Decode for StorageHasher

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

impl Decode for StorageEntryModifier

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

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

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

impl Decode for RuntimeMetadataPrefixed

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

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,

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

impl Decode for RuntimeMetadataV14

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

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

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

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

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

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

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

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

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

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

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

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

impl Decode for OpaqueMetadata

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

impl Decode for RuntimeMetadataDeprecated

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Decode for TypeDefPrimitive

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,

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

impl Decode for PortableRegistry

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,

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

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

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

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

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

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,

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

impl Decode for AccountId32

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

impl Decode for HttpError

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

impl Decode for LogLevel

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

impl Decode for HttpRequestId

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

impl Decode for OpaqueNetworkState

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

impl Decode for DeriveJunction

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

impl Decode for NeverNativeValue

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

impl Decode for Timestamp

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

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

impl Decode for StorageKind

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

impl Decode for OpaquePeerId

fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaquePeerId, 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 Duration

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

impl Decode for Void

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

impl Decode for LogLevelFilter

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

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

impl Decode for CryptoTypeId

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

impl Decode for OpaqueMultiaddr

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

impl Decode for OpaqueMetadata

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

impl Decode for CryptoTypePublicPair

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

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

impl Decode for KeyTypeId

fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<KeyTypeId, 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 Value

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

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

impl Decode for TrackedStorageKey

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

impl Decode for H160

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

fn decode<I>(input: &mut I) -> Result<H512, 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 H256

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

impl Decode for EcdsaVerifyError

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

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

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

impl Decode for CompactProof

fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CompactProof, 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 RuntimeString

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

impl Decode for Time

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

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

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

impl Decode for Justifications

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

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

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

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

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

impl Decode for BadOrigin

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

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

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

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

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

impl Decode for TransactionalError

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

impl Decode for DispatchError

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

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

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

impl Decode for OpaqueExtrinsic

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

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

impl Decode for TokenError

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

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

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

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

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

impl Decode for ModuleError

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

impl Decode for UintAuthorityId

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

impl Decode for DigestItem

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

impl Decode for TestSignature

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

impl Decode for Era

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

impl Decode for MultiSigner

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

impl Decode for AnySignature

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

impl Decode for Digest

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

impl Decode for ArithmeticError

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

impl Decode for LookupError

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

impl Decode for ModuleError

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

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

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

impl Decode for MultiSignature

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

fn decode<I>(
    input: &mut I
) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extra>, 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 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 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 BigUint

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

impl Decode for FixedI64

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

impl Decode for PerU16

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

impl Decode for FixedU64

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

impl Decode for Permill

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

impl Decode for FixedI128

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

impl Decode for Perbill

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

impl Decode for Percent

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

impl Decode for FixedU128

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

impl Decode for Perquintill

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

impl Decode for CheckInherentsResult

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

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

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

impl Decode for DisableStrategy

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,

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

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

impl<T> Decode for Error<T>

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

impl Decode for LastRuntimeUpgradeInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Decode for BlockWeights

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

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

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

impl Decode for BlockLength

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

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

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

impl Decode for Phase

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

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

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

impl Decode for WeightsPerClass

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

impl<T> Decode for Error<T>

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

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

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

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

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

impl Decode for BenchmarkResult

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

impl Decode for BenchmarkConfig

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

impl Decode for BenchmarkBatchSplitResults

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

impl Decode for BenchmarkBatch

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

impl Decode for BenchmarkParameter

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

impl Decode for BenchmarkMetadata

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

impl Decode for BenchmarkList

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

impl Decode for Reasons

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

impl<T, I> Decode for Error<T, I>

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

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

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

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

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

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

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

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

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

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

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

Implementors

impl Decode for Accounts

impl Decode for DispatchClass

impl Decode for pallet_roles::DispatchError

impl Decode for InvalidTransaction

impl Decode for Pays

impl Decode for TransactionSource

impl Decode for TransactionValidityError

impl Decode for UnknownTransaction

impl Decode for ChildInfo

impl Decode for KillStorageResult

impl Decode for MultiRemovalResults

impl Decode for InherentData

impl Decode for PalletId

impl Decode for StorageVersion

impl Decode for ValidTransaction

impl Decode for Weight

impl Decode for WithdrawReasons

impl Decode for Compact<u8>

impl Decode for Compact<u16>

impl Decode for Compact<u32>

impl Decode for Compact<u64>

impl Decode for Compact<u128>

impl Decode for Compact<()>

impl Decode for OptionBool

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

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

impl<T> Decode for pallet_roles::pallet::Error<T>

impl<T> Decode for PhantomData<T>

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

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

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

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

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

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

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

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

impl<T: Config> Decode for HouseSeller<T>where
    T::AccountId: Decode,
    BlockNumberOf<T>: Decode,

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

impl<T: Config> Decode for Notary<T>where
    T::AccountId: Decode,
    BlockNumberOf<T>: Decode,

impl<T: Config> Decode for Representative<T>where
    T::AccountId: Decode,
    BlockNumberOf<T>: Decode,
    Vec<T::AccountId>: Decode,

impl<T: Config> Decode for Servicer<T>where
    T::AccountId: Decode,
    BlockNumberOf<T>: Decode,

impl<T: Config> Decode for Tenant<T>where
    T::AccountId: Decode,
    BalanceOf<T>: Decode,
    BlockNumberOf<T>: Decode,
    Option<T::AccountId>: Decode,