Trait Decode 

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

    // Provided methods
    fn decode_into<I>(
        input: &mut I,
        dst: &mut MaybeUninit<Self>,
    ) -> Result<DecodeFinished, 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 decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

The default implementation will just call Decode::decode.

Safety

If this function returns Ok then dst must be properly initialized.

This is enforced by requiring the implementation to return a DecodeFinished which can only be created by calling DecodeFinished::assert_decoding_finished which is unsafe.

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Decode for ()

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

where I: Input,

impl Decode for AppId

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AppId, Error>

where __CodecInputEdqy: Input,

impl Decode for AuthorityId

fn decode<I>(input: &mut I) -> Result<AuthorityId, Error>

where I: Input,

impl Decode for Cell

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Cell, Error>

where __CodecInputEdqy: Input,

impl Decode for Commit

fn decode<I>(input: &mut I) -> Result<Commit, Error>

where I: Input,

impl Decode for DataLookupItem

fn decode<I>(input: &mut I) -> Result<DataLookupItem, Error>

where I: Input,

impl Decode for DispatchClass

fn decode<I>(input: &mut I) -> Result<DispatchClass, Error>

where I: Input,

impl Decode for ExtrinsicAdditional

fn decode<I>(input: &mut I) -> Result<ExtrinsicAdditional, Error>

where I: Input,

impl Decode for FeeDetails

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<FeeDetails, Error>

where __CodecInputEdqy: Input,

impl Decode for GenericExtrinsic<'_>

fn decode<I>(input: &mut I) -> Result<GenericExtrinsic<'_>, Error>

where I: Input,

impl Decode for InclusionFee

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<InclusionFee, Error>

where __CodecInputEdqy: Input,

impl Decode for Metadata

fn decode<I>(input: &mut I) -> Result<Metadata, Error>

where I: Input,

impl Decode for MultiSignature

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

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PerDispatchClassWeight, Error>

where __CodecInputEdqy: Input,

impl Decode for PreDigest

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PreDigest, Error>

where __CodecInputEdqy: Input,

impl Decode for Precommit

fn decode<I>(input: &mut I) -> Result<Precommit, Error>

where I: Input,

impl Decode for PrimaryPreDigest

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PrimaryPreDigest, Error>

where __CodecInputEdqy: Input,

impl Decode for RuntimeDispatchInfo

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

Available on crate feature decode only.

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

where I: Input,

impl Decode for RuntimeMetadataPrefixed

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV14

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV15

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeMetadataV15, Error>

where __CodecInputEdqy: Input,

impl Decode for RuntimePhase

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimePhase, Error>

where __CodecInputEdqy: Input,

impl Decode for SecondaryPlainPreDigest

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SecondaryPlainPreDigest, Error>

where __CodecInputEdqy: Input,

impl Decode for SecondaryVRFPreDigest

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SecondaryVRFPreDigest, Error>

where __CodecInputEdqy: Input,

impl Decode for Signature

fn decode<I>(input: &mut I) -> Result<Signature, Error>

where I: Input,

impl Decode for SignedPrecommit

fn decode<I>(input: &mut I) -> Result<SignedPrecommit, Error>

where I: Input,

impl Decode for StorageEntryModifier

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

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

where I: Input,

impl Decode for VrfPreOutput

fn decode<R>(i: &mut R) -> Result<VrfPreOutput, Error>

where R: Input,

impl Decode for VrfProof

fn decode<R>(i: &mut R) -> Result<VrfProof, Error>

where R: Input,

impl Decode for VrfSignature

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<VrfSignature, Error>

where __CodecInputEdqy: Input,

impl Decode for bool

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for f32

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for f64

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i8

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

where I: Input,

impl Decode for i16

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i32

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i64

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i128

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u8

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

where I: Input,

impl Decode for u16

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u32

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u64

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u128

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

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<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<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<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<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<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<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<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<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<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<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<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<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<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<N> Decode for ConsensusLog<N>

where N: Codec + Decode, ScheduledChange<N>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ConsensusLog<N>, Error>

where __CodecInputEdqy: Input,

impl<N> Decode for ScheduledChange<N>

where N: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ScheduledChange<N>, Error>

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

where R0: Decode,

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

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<[T; N]>, ) -> Result<DecodeFinished, Error>

where I: Input,

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl<T> Decode for Cow<'_, T>

where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode,

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

where I: Input,

impl<T> Decode for CustomMetadata<T>

where T: Form, BTreeMap<<T as Form>::String, CustomValueMetadata<T>>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for CustomValueMetadata<T>

where T: Form, <T as Form>::Type: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for ExtrinsicMetadata<T>

where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for ExtrinsicMetadata<T>

where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for OuterEnums<T>

where T: Form, <T as Form>::Type: Decode,

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

where __CodecInputEdqy: 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<T> Decode for PalletConstantMetadata<T>

where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletErrorMetadata<T>

where T: Form, <T as Form>::Type: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletErrorMetadata<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 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>>: Decode, Option<PalletErrorMetadata<T>>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletStorageMetadata<T>

where T: Form, <T as Form>::String: Decode, Vec<StorageEntryMetadata<T>>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for RuntimeApiMetadata<T>

where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for RuntimeApiMethodMetadata<T>

where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodParamMetadata<T>>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for RuntimeApiMethodParamMetadata<T>

where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

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

where T: Form, <T as Form>::String: Decode, StorageEntryType<T>: Decode, Vec<<T as Form>::String>: Decode,

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

Implementors

impl Decode for AccountData

impl Decode for AccountId20

impl Decode for AccountId32

impl Decode for AccountInfo

impl Decode for AddProxy

impl Decode for AddressedMessage

impl Decode for Announced

impl Decode for AppKey

impl Decode for ApplicationKeyCreated

impl Decode for ApproveAsMulti

impl Decode for ArithmeticError

impl Decode for AsMulti

impl Decode for AsMultiThreshold1

impl Decode for AvailHeader

impl Decode for BalanceStatus

impl Decode for Batch

impl Decode for BatchAll

impl Decode for BatchCompleted

impl Decode for BatchCompletedWithErrors

impl Decode for BatchInterrupted

impl Decode for Bits

impl Decode for Bond

impl Decode for avail_rust_client::avail::nomination_pools::tx::BondExtra

impl Decode for avail_rust_client::avail::staking::tx::BondExtra

impl Decode for BondExtraOther

impl Decode for BondExtraValue

impl Decode for Bonded

impl Decode for CancelAsMulti

impl Decode for avail_rust_client::avail::nomination_pools::tx::Chill

impl Decode for avail_rust_client::avail::staking::tx::Chill

impl Decode for ChillOther

impl Decode for Chilled

impl Decode for ClaimCommission

impl Decode for ClaimPayout

impl Decode for ClaimPayoutOther

impl Decode for ClaimPermission

impl Decode for Compact<()>

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 CompactDataLookup

impl Decode for ConfigOpAccount

impl Decode for Configuration

impl Decode for Create

impl Decode for CreateApplicationKey

impl Decode for CreatePure

impl Decode for CreateWithPoolId

impl Decode for DataSubmitted

impl Decode for Deposit

impl Decode for DeriveJunction

impl Decode for Digest

impl Decode for DigestItem

impl Decode for DispatchError

impl Decode for DispatchFeeModifier

impl Decode for DispatchInfo

impl Decode for DispatchedAs

impl Decode for Duration

impl Decode for DustLost

impl Decode for EnableMock

impl Decode for EncodedExtrinsic

impl Decode for Endowed

impl Decode for Era

impl Decode for EraPaid

impl Decode for Execute

impl Decode for ExtrinsicCall

impl Decode for ExtrinsicExtra

impl Decode for ExtrinsicFailed

impl Decode for ExtrinsicSignature

impl Decode for ExtrinsicSuccess

impl Decode for FailedSendMessageTxs

impl Decode for ForceApplyMinCommission

impl Decode for ForceBatch

impl Decode for Frozen

impl Decode for Fulfill

impl Decode for FulfillCall

impl Decode for GrandpaJustification

impl Decode for H128

impl Decode for H160

impl Decode for H256

impl Decode for H384

impl Decode for H512

impl Decode for H768

impl Decode for HeaderExtension

impl Decode for ItemCompleted

impl Decode for ItemFailed

impl Decode for Join

impl Decode for KateCommitment

impl Decode for Kick

impl Decode for Kicked

impl Decode for KillPure

impl Decode for Locked

impl Decode for Message

impl Decode for avail_rust_client::ext::subxt_core::Metadata

impl Decode for MockFulfill

impl Decode for ModuleError

impl Decode for avail_rust_client::MultiAddress

impl Decode for avail_rust_client::ext::subxt_core::utils::MultiSignature

impl Decode for MultisigApproval

impl Decode for MultisigCancelled

impl Decode for MultisigExecuted

impl Decode for NewMultisig

impl Decode for avail_rust_client::avail::nomination_pools::tx::Nominate

impl Decode for avail_rust_client::avail::staking::tx::Nominate

impl Decode for NonZero<i8>

impl Decode for NonZero<i16>

impl Decode for NonZero<i32>

impl Decode for NonZero<i64>

impl Decode for NonZero<i128>

impl Decode for NonZero<u8>

impl Decode for NonZero<u16>

impl Decode for NonZero<u32>

impl Decode for NonZero<u64>

impl Decode for NonZero<u128>

impl Decode for OptionBool

impl Decode for PayoutStakers

impl Decode for PayoutStakersByPage

impl Decode for PayoutStarted

impl Decode for Pays

impl Decode for Phase

impl Decode for PoolState

impl Decode for PortableRegistry

impl Decode for PortableType

impl Decode for Proxy

impl Decode for ProxyAdded

impl Decode for ProxyExecuted

impl Decode for ProxyRemoved

impl Decode for ProxyType

impl Decode for PureCreated

impl Decode for PurgeKeys

impl Decode for ReapStash

impl Decode for Rebond

impl Decode for Remark

impl Decode for RemarkWithEvent

impl Decode for RemoveProxies

impl Decode for RemoveProxy

impl Decode for Reserved

impl Decode for RewardDestination

impl Decode for Rewarded

impl Decode for RuntimeCall

impl Decode for SendMessage

impl Decode for Set

impl Decode for SetBroadcaster

impl Decode for SetClaimPermission

impl Decode for SetCode

impl Decode for SetCodeWithoutChecks

impl Decode for SetCommission

impl Decode for SetCommissionChangeRate

impl Decode for SetCommissionMax

impl Decode for SetConfiguration

impl Decode for SetController

impl Decode for SetFunctionIds

impl Decode for SetKeys

impl Decode for SetMetadata

impl Decode for SetPayee

impl Decode for SetPoseidonHash

impl Decode for SetRotateVerificationKey

impl Decode for SetSp1VerificationKey

impl Decode for SetState

impl Decode for SetStepVerificationKey

impl Decode for SetSyncCommitteeHash

impl Decode for SetUpdater

impl Decode for SetWhitelistedDomains

impl Decode for avail_rust_client::avail::balances::events::Slashed

impl Decode for avail_rust_client::avail::staking::events::Slashed

impl Decode for SourceChainFroze

impl Decode for StoredPendingChange

impl Decode for StoredState

impl Decode for SubmitData

impl Decode for Thawed

impl Decode for Timepoint

impl Decode for TokenError

impl Decode for TransactionFeePaid

impl Decode for TransactionalError

impl Decode for Transfer

impl Decode for TransferAll

impl Decode for TransferAllowDeath

impl Decode for TransferKeepAlive

impl Decode for TypeDefPrimitive

impl Decode for U128

impl Decode for U256

impl Decode for U512

impl Decode for avail_rust_client::avail::nomination_pools::tx::Unbond

impl Decode for avail_rust_client::avail::staking::tx::Unbond

impl Decode for Unbonded

impl Decode for Unlocked

impl Decode for Unreserved

impl Decode for UpdateRoles

impl Decode for UpdatedInactive

impl Decode for V3HeaderExtension

impl Decode for Validate

impl Decode for ValidatorPrefs

impl Decode for ValidatorPrefsSet

impl Decode for Weight

impl Decode for avail_rust_client::avail::balances::events::Withdraw

impl Decode for avail_rust_client::avail::staking::events::Withdraw

impl Decode for avail_rust_client::avail::nomination_pools::tx::WithdrawUnbonded

impl Decode for avail_rust_client::avail::staking::tx::WithdrawUnbonded

impl<AccountId, AccountIndex> Decode for avail_rust_client::ext::subxt_core::utils::MultiAddress<AccountId, AccountIndex>

where AccountId: Decode, AccountIndex: HasCompact,

impl<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra>

impl<K, V> Decode for BTreeMap<K, V>

where K: Decode + Ord, V: Decode,

impl<N, H> Decode for SubstrateHeader<N, H>

where N: Copy + Into<U256> + TryFrom<U256> + HasCompact, H: Hasher, <H as Hasher>::Output: Decode,

impl<Store, Order> Decode for DecodedBits<Store, Order>

where Store: BitStore, Order: BitOrder,

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

where T: Decode, E: Decode,

impl<T, X> Decode for X

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

impl<T> Decode for BTreeSet<T>

where T: Decode + Ord,

impl<T> Decode for BinaryHeap<T>

where T: Decode + Ord,

impl<T> Decode for Compact<T>

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

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

impl<T> Decode for LinkedList<T>

where T: Decode,

impl<T> Decode for Option<T>

where T: Decode,

impl<T> Decode for Path<T>

where T: Form, Vec<<T as Form>::String>: Decode,

impl<T> Decode for PhantomData<T>

impl<T> Decode for Range<T>

where T: Decode,

impl<T> Decode for RangeInclusive<T>

where T: Decode,

impl<T> Decode for Static<T>

where T: Decode,

impl<T> Decode for Type<T>

where T: Form, Path<T>: Decode, Vec<TypeParameter<T>>: Decode, TypeDef<T>: Decode, Vec<<T as Form>::String>: Decode,

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,

impl<T> Decode for TypeDefArray<T>

where T: Form, <T as Form>::Type: Decode,

impl<T> Decode for TypeDefBitSequence<T>

where T: Form, <T as Form>::Type: Decode,

impl<T> Decode for TypeDefCompact<T>

where T: Form, <T as Form>::Type: Decode,

impl<T> Decode for TypeDefComposite<T>

where T: Form, Vec<Field<T>>: Decode,

impl<T> Decode for TypeDefSequence<T>

where T: Form, <T as Form>::Type: Decode,

impl<T> Decode for TypeDefTuple<T>

where T: Form, Vec<<T as Form>::Type>: Decode,

impl<T> Decode for TypeDefVariant<T>

where T: Form, Vec<Variant<T>>: Decode,

impl<T> Decode for TypeParameter<T>

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

impl<T> Decode for UntrackedSymbol<T>

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

impl<T> Decode for Variant<T>

where T: Form, <T as Form>::String: Decode, Vec<Field<T>>: Decode, Vec<<T as Form>::String>: Decode,

impl<T> Decode for Vec<T>

where T: Decode,

impl<T> Decode for VecDeque<T>

where T: Decode,

impl<T> Decode for VerifySignatureDetails<T>

where T: Config, <T as Config>::Signature: Decode, <T as Config>::AccountId: Decode,

impl<T> Decode for WrapperKeepOpaque<T>

where PhantomDataSendSync<T>: Decode,