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", so this trait is not object safe.

Implementations on Foreign Types

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 Decode for ()

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

where I: Input,

impl Decode for String

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

where I: Input,

impl Decode for NonZero<i8>

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

where I: Input,

impl Decode for NonZero<i16>

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

where I: Input,

impl Decode for NonZero<i32>

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

where I: Input,

impl Decode for NonZero<i64>

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

where I: Input,

impl Decode for NonZero<i128>

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

where I: Input,

impl Decode for NonZero<u8>

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

where I: Input,

impl Decode for NonZero<u16>

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

where I: Input,

impl Decode for NonZero<u32>

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

where I: Input,

impl Decode for NonZero<u64>

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

where I: Input,

impl Decode for NonZero<u128>

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

where I: Input,

impl Decode for Duration

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

where I: Input,

impl Decode for AccountId32

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

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

where __CodecInputEdqy: Input,

impl Decode for BadOrigin

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

where __CodecInputEdqy: Input,

impl Decode for BalanceStatus

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

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

where __CodecInputEdqy: Input,

impl Decode for BlockWeights

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

where __CodecInputEdqy: Input,

impl Decode for Bytes

Available on crate feature bytes only.

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

where I: Input,

impl Decode for CheckInherentsResult

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

where __CodecInputEdqy: Input,

impl Decode for ChildInfo

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

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

where __CodecInputEdqy: Input,

impl Decode for ContextualAlias

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

where __CodecInputEdqy: Input,

impl Decode for CrateVersion

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

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

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

where I: Input,

impl Decode for Disabled

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

where __CodecInputEdqy: Input,

impl Decode for DispatchClass

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

where __CodecInputEdqy: Input,

impl Decode for DispatchError

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

where __CodecInputEdqy: Input,

impl Decode for DispatchError

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

where __CodecInputEdqy: Input,

impl Decode for DispatchEventInfo

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

where __CodecInputEdqy: Input,

impl Decode for DispatchInfo

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

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

where __CodecInputEdqy: Input,

impl Decode for ElectionScore

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

where __CodecInputEdqy: Input,

impl Decode for Era

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

where I: Input,

impl Decode for Error

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

where __CodecInputEdqy: Input,

impl Decode for ErrorMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ErrorMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ErrorMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ErrorMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ErrorMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ErrorMetadata

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

where __CodecInputEdqy: Input,

impl Decode for EventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for EventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for EventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for EventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for EventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for EventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ExtrinsicInclusionMode

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

where __CodecInputEdqy: Input,

impl Decode for ExtrinsicMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ExtrinsicMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ExtrinsicMetadata

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

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

where __CodecInputEdqy: Input,

impl Decode for FixedU64

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

where __CodecInputEdqy: Input,

impl Decode for FixedU128

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

where __CodecInputEdqy: Input,

impl Decode for Footprint

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

where __CodecInputEdqy: Input,

impl Decode for FunctionArgumentMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionArgumentMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionArgumentMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionArgumentMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionArgumentMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionArgumentMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionMetadata

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

where __CodecInputEdqy: Input,

impl Decode for FunctionMetadata

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

where __CodecInputEdqy: Input,

impl Decode for H128

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

where I: Input,

impl Decode for H160

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

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

where I: Input,

impl Decode for H768

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

where I: Input,

impl Decode for HttpError

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

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

where __CodecInputEdqy: Input,

impl Decode for InherentData

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

where __CodecInputEdqy: Input,

impl Decode for InvalidTransaction

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

where __CodecInputEdqy: Input,

impl Decode for Judgement

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

where __CodecInputEdqy: Input,

impl Decode for Justifications

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

where __CodecInputEdqy: Input,

impl Decode for KeyTypeId

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

where __CodecInputEdqy: Input,

fn decode_into<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<KeyTypeId>, ) -> Result<DecodeFinished, Error>

where __CodecInputEdqy: Input,

impl Decode for KillStorageResult

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

where __CodecInputEdqy: Input,

impl Decode for LastRuntimeUpgradeInfo

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

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

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

where __CodecInputEdqy: Input,

impl Decode for ModuleConstantMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleConstantMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleConstantMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleConstantMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleConstantMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleConstantMetadata

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

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

where __CodecInputEdqy: Input,

impl Decode for ModuleMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleMetadata

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

where __CodecInputEdqy: Input,

impl Decode for ModuleMetadata

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

where __CodecInputEdqy: Input,

impl Decode for MultiRemovalResults

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

where __CodecInputEdqy: Input,

impl Decode for MultiSignature

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

where __CodecInputEdqy: Input,

impl Decode for MultiSigner

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

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

where __CodecInputEdqy: Input,

impl Decode for OpaqueExtrinsic

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for OuterEventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for OuterEventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for OuterEventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for OuterEventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for OuterEventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for OuterEventMetadata

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

where __CodecInputEdqy: Input,

impl Decode for PalletId

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

where __CodecInputEdqy: Input,

impl Decode for Pays

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

where __CodecInputEdqy: Input,

impl Decode for PerU16

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

where I: 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 Permill

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

where I: Input,

impl Decode for Perquintill

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

where I: Input,

impl Decode for Phase

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

where __CodecInputEdqy: Input,

impl Decode for PortableRegistry

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

where __CodecInputEdqy: Input,

impl Decode for PortableType

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

where __CodecInputEdqy: Input,

impl Decode for PostDispatchInfo

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

where __CodecInputEdqy: Input,

impl Decode for ProcessMessageError

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

where __CodecInputEdqy: Input,

impl Decode for ProofOfPossession

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

where __CodecInputEdqy: Input,

impl Decode for ProofOfPossession

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

where __CodecInputEdqy: Input,

impl Decode for ProofOfPossession

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

where __CodecInputEdqy: Input,

impl Decode for ProofOfPossession

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

where __CodecInputEdqy: Input,

impl Decode for ProofOfPossession

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

where __CodecInputEdqy: Input,

impl Decode for ProofOfPossession

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

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

where __CodecInputEdqy: Input,

impl Decode for RingVerifierKey

fn decode<R>(input: &mut R) -> Result<RingVerifierKey, Error>

where R: Input,

impl Decode for RingVrfSignature

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

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV9

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV10

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV11

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV12

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataV13

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

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeVersion

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

where I: Input,

impl Decode for Select

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

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

where __CodecInputEdqy: Input,

impl Decode for Social

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

where __CodecInputEdqy: Input,

impl Decode for StateVersion

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

where __CodecInputEdqy: Input,

impl Decode for Statement

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

where __CodecInputEdqy: Input,

impl Decode for SteppedMigrationError

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

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryModifier

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryType

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryType

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryType

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryType

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryType

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

where __CodecInputEdqy: Input,

impl Decode for StorageEntryType

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for StorageMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageMetadata

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

where __CodecInputEdqy: Input,

impl Decode for StorageMetadata

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

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

where __CodecInputEdqy: Input,

impl Decode for StorageVersion

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

where __CodecInputEdqy: Input,

impl Decode for TestSignature

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

where __CodecInputEdqy: Input,

impl Decode for Time

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

where __CodecInputEdqy: Input,

impl Decode for Timestamp

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

where __CodecInputEdqy: Input,

impl Decode for TokenError

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

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

where __CodecInputEdqy: Input,

impl Decode for TransactionValidityError

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

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

where __CodecInputEdqy: Input,

impl Decode for TrieError

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

where __CodecInputEdqy: Input,

impl Decode for Truth

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

where __CodecInputEdqy: Input,

impl Decode for TypeDefPrimitive

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

where __CodecInputEdqy: Input,

impl Decode for U128

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

where I: Input,

impl Decode for U256

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

where I: Input,

impl Decode for U512

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

where I: Input,

impl Decode for UintAuthorityId

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

where __CodecInputEdqy: Input,

impl Decode for UnknownTransaction

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

where __CodecInputEdqy: Input,

impl Decode for UpgradeCheckSelect

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

where __CodecInputEdqy: Input,

impl Decode for ValidTransaction

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

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

where __CodecInputEdqy: Input,

impl Decode for ViewFunctionDispatchError

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

where __CodecInputEdqy: Input,

impl Decode for ViewFunctionId

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

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

where R: 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 VrfSignature

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

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

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

where __CodecInputEdqy: Input,

impl Decode for WasmMetadata

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

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

where __CodecInputEdqy: Input,

impl Decode for WeightsPerClass

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

where __CodecInputEdqy: Input,

impl Decode for WithdrawReasons

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

where __CodecInputEdqy: 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<A, F, R, D, Fp> Decode for FreezeConsideration<A, F, R, D, Fp>

where F: Mutate<A>, <F as Inspect<A>>::Balance: Decode, PhantomData<fn() -> (A, R, D, Fp)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<FreezeConsideration<A, F, R, D, Fp>, Error>

where __CodecInputEdqy: Input,

impl<A, F, R, D, Fp> Decode for HoldConsideration<A, F, R, D, Fp>

where F: Mutate<A>, <F as Inspect<A>>::Balance: Decode, PhantomData<fn() -> (A, R, D, Fp)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<HoldConsideration<A, F, R, D, Fp>, Error>

where __CodecInputEdqy: Input,

impl<A, Fx, Rx, D, Fp> Decode for LoneFreezeConsideration<A, Fx, Rx, D, Fp>

where PhantomData<fn() -> (A, Fx, Rx, D, Fp)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<LoneFreezeConsideration<A, Fx, Rx, D, Fp>, Error>

where __CodecInputEdqy: Input,

impl<A, Fx, Rx, D, Fp> Decode for LoneHoldConsideration<A, Fx, Rx, D, Fp>

where PhantomData<fn() -> (A, Fx, Rx, D, Fp)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<LoneHoldConsideration<A, Fx, Rx, D, Fp>, Error>

where __CodecInputEdqy: Input,

impl<AccountId> Decode for Admin<AccountId>

where PhantomData<AccountId>: Decode,

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

where __CodecInputEdqy: Input,

impl<AccountId> Decode for Owner<AccountId>

where PhantomData<AccountId>: Decode,

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

where __CodecInputEdqy: Input,

impl<AccountId> Decode for RawOrigin<AccountId>

where AccountId: Decode,

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

where __CodecInputEdqy: Input,

impl<AccountId> Decode for StakedAssignment<AccountId>

where AccountId: Decode, Vec<(AccountId, u128)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StakedAssignment<AccountId>, 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<AccountId, Balance> Decode for Exposure<AccountId, Balance>

where Balance: HasCompact, Vec<IndividualExposure<AccountId, Balance>>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Exposure<AccountId, Balance>, Error>

where __CodecInputEdqy: Input,

impl<AccountId, Balance> Decode for ExposurePage<AccountId, Balance>

where Balance: HasCompact, Vec<IndividualExposure<AccountId, Balance>>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ExposurePage<AccountId, Balance>, Error>

where __CodecInputEdqy: Input,

impl<AccountId, Balance> Decode for IndividualExposure<AccountId, Balance>

where Balance: HasCompact, AccountId: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<IndividualExposure<AccountId, Balance>, Error>

where __CodecInputEdqy: Input,

impl<Address, Call, Signature, ExtensionV0, ExtensionOtherVersions, const MAX_CALL_SIZE: usize> Decode for UncheckedExtrinsic<Address, Call, Signature, ExtensionV0, ExtensionOtherVersions, MAX_CALL_SIZE>

where Address: DecodeWithMemTracking, Signature: DecodeWithMemTracking, Call: DecodeWithMemTracking, ExtensionV0: DecodeWithMemTracking, ExtensionOtherVersions: DecodeWithVersionWithMemTracking,

fn decode<I>( input: &mut I, ) -> Result<UncheckedExtrinsic<Address, Call, Signature, ExtensionV0, ExtensionOtherVersions, MAX_CALL_SIZE>, Error>

where I: Input,

impl<Address, Signature, ExtensionV0, ExtensionOtherVersions> Decode for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>

where Address: Decode, Signature: Decode, ExtensionV0: Decode, ExtensionOtherVersions: DecodeWithVersion,

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

where I: Input,

impl<AssetId> Decode for NativeOrWithId<AssetId>

where AssetId: Ord + Decode,

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

where __CodecInputEdqy: 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<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<B, O> Decode for DecodeDifferent<B, O>

where B: 'static, O: Decode + 'static,

Available on crate feature std only.

fn decode<I>(input: &mut I) -> Result<DecodeDifferent<B, O>, Error>

where I: Input,

impl<B, OnDrop, OppositeOnDrop> Decode for Imbalance<B, OnDrop, OppositeOnDrop>

where B: Balance + Decode, OnDrop: HandleImbalanceDrop<B>, OppositeOnDrop: HandleImbalanceDrop<B>, PhantomData<(OnDrop, OppositeOnDrop)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Imbalance<B, OnDrop, OppositeOnDrop>, Error>

where __CodecInputEdqy: Input,

impl<Balance> Decode for PagedExposureMetadata<Balance>

where Balance: HasCompact + MaxEncodedLen,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PagedExposureMetadata<Balance>, 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<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<Block> Decode for SignedBlock<Block>

where Block: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SignedBlock<Block>, 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<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<ConfigValue, Extra> Decode for WithConfig<ConfigValue, Extra>

where ConfigValue: ConfigValueMarker + Decode, Extra: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<WithConfig<ConfigValue, Extra>, Error>

where __CodecInputEdqy: 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<E, T> Decode for EventRecord<E, T>

where E: Parameter + Member + Decode, Vec<T>: Decode,

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

where __CodecInputEdqy: 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<H> Decode for IgnoredNodes<H>

where H: Decode + Hash + Eq,

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

where I: Input,

impl<H, L> Decode for MerkleProof<H, L>

where H: Decode, Vec<H>: Decode, L: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<MerkleProof<H, L>, Error>

where __CodecInputEdqy: Input,

impl<Header, Extrinsic> Decode for Block<Header, Extrinsic>

where Header: Decode, Vec<Extrinsic>: Decode,

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

where __CodecInputEdqy: Input,

impl<Header, Extrinsic> Decode for LazyBlock<Header, Extrinsic>

where Header: Decode, PhantomData<Extrinsic>: Decode,

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

where __CodecInputEdqy: 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<Id, Balance> Decode for IdAmount<Id, Balance>

where Id: Decode, Balance: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<IdAmount<Id, Balance>, Error>

where __CodecInputEdqy: Input,

impl<Info> Decode for DispatchErrorWithPostInfo<Info>

where Info: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable,

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

where __CodecInputEdqy: Input,

impl<Inner> Decode for FakeDispatchable<Inner>

where Inner: Decode,

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

where __CodecInputEdqy: Input,

impl<Inspect> Decode for ConfigValue<Inspect>

where Inspect: InspectStrategy, <Inspect as InspectStrategy>::Value: Decode,

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

where __CodecInputEdqy: 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<K, V> Decode for BTreeMap<K, V>

where K: Decode + Ord, V: Decode,

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

where I: Input,

impl<K, V, S> Decode for BoundedBTreeMap<K, V, S>

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

fn decode<I>(input: &mut I) -> Result<BoundedBTreeMap<K, V, S>, Error>

where I: Input,

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

where I: Input,

impl<Keys, Proof> Decode for GeneratedSessionKeys<Keys, Proof>

where Keys: Decode, Proof: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<GeneratedSessionKeys<Keys, Proof>, Error>

where __CodecInputEdqy: 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<Nonce, AccountData> Decode for AccountInfo<Nonce, AccountData>

where Nonce: Decode, AccountData: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AccountInfo<Nonce, AccountData>, 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<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<O, T> Decode for BitBox<T, O>

where O: BitOrder, T: BitStore + Decode,

fn decode<I>(input: &mut I) -> Result<BitBox<T, O>, Error>

where I: Input,

impl<O, T> Decode for BitVec<T, O>

where O: BitOrder, T: BitStore + Decode,

fn decode<I>(input: &mut I) -> Result<BitVec<T, O>, Error>

where I: 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<Params, ReportedId> Decode for DeriveAndReportId<Params, ReportedId>

where Params: Decode, PhantomData<ReportedId>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<DeriveAndReportId<Params, ReportedId>, Error>

where __CodecInputEdqy: Input,

impl<Params, RuntimeCall> Decode for Callback<Params, RuntimeCall>

where PhantomData<(Params, RuntimeCall)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Callback<Params, RuntimeCall>, Error>

where __CodecInputEdqy: 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<Reporter, Offender> Decode for OffenceDetails<Reporter, Offender>

where Offender: Decode, Vec<Reporter>: Decode,

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

where __CodecInputEdqy: Input,

impl<SE> Decode for AsTransactionExtension<SE>

where SE: SignedExtension + Decode,

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

where __CodecInputEdqy: Input,

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 Option<T>

where T: Decode,

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

where I: 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<T> Decode for BTreeSet<T>

where T: Decode + Ord,

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

where T: Decode,

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

where I: Input,

impl<T> Decode for Vec<T>

where T: Decode,

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

where I: Input,

impl<T> Decode for PhantomData<T>

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

where I: Input,

impl<T> Decode for Range<T>

where T: Decode,

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

where PhantomData<T>: Decode,

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

where PhantomData<T>: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for CheckNonce<T>

where T: Config, <T as Config>::Nonce: HasCompact,

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

where T: Config, <T as Config>::Hash: Decode,

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

where __CodecInputEdqy: 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 EnumDeprecationInfo<T>

where T: Form, BTreeMap<u8, VariantDeprecationInfo<T>>: Decode,

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

where T: Config, <T as Config>::Hash: Decode, <T as Config>::AccountId: Decode, <T as Config>::RuntimeTask: Decode,

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

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for ItemDeprecationInfo<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for NoDrop<T>

where T: Default + Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletCallMetadata<T>

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

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

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

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

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletEventMetadata<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, 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 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<PalletAssociatedTypeMetadata<T>>: Decode, Vec<PalletViewFunctionMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<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,

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 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 PalletViewFunctionMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletViewFunctionMetadataIR<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletViewFunctionParamMetadataIR<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Path<T>

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

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

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

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

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

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

impl<T> Decode for TransactionExtensionMetadata<T>

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

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

where __CodecInputEdqy: Input,

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,

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

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

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for TypeDefVariant<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for TypeParameter<T>

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

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for VariantDeprecationInfo<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for WeightReclaim<T>

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

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<WeightReclaim<T>, 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<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<T, D> Decode for TypeWithDefault<T, D>

where D: Get<T>, T: Decode, PhantomData<D>: Decode,

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

where __CodecInputEdqy: 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<T, H> Decode for Bounded<T, H>

where H: Hash, <H as Hash>::Output: Decode, PhantomData<T>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Bounded<T, H>, 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<T, S> Decode for BoundedBTreeSet<T, S>

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

fn decode<I>(input: &mut I) -> Result<BoundedBTreeSet<T, S>, Error>

where I: Input,

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

where I: Input,

impl<T, S> Decode for WeakBoundedVec<T, S>

where T: Decode, S: Get<u32>,

fn decode<I>(input: &mut I) -> Result<WeakBoundedVec<T, S>, Error>

where I: Input,

fn skip<I>(input: &mut I) -> Result<(), 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<WitnessData> Decode for Witness<WitnessData>

where PhantomData<WitnessData>: Decode,

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

where __CodecInputEdqy: Input,

impl<Xt> Decode for Block<Xt>

where Vec<Xt>: Decode,

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

where __CodecInputEdqy: Input,

impl<const N: usize> Decode for MigrationId<N>

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

where __CodecInputEdqy: Input,

impl<const N: usize, T> Decode for CryptoBytes<N, T>

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

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

where __CodecInputEdqy: Input,

fn decode_into<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<CryptoBytes<N, T>>, ) -> Result<DecodeFinished, Error>

where __CodecInputEdqy: Input,

impl<const R: usize> Decode for RingContext<R>

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

where I: Input,

Implementors

impl Decode for frame_election_provider_support::Error

impl Decode for Weight

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 Support<AccountId>

where Vec<(AccountId, u128)>: Decode,

impl<AccountId, BOuter: Get<u32>, BInner: Get<u32>> Decode for BoundedSupports<AccountId, BOuter, BInner>

where BoundedVec<(AccountId, BoundedSupport<AccountId, BInner>), BOuter>: Decode,

impl<AccountId, Bound: Get<u32>> Decode for BoundedSupport<AccountId, Bound>

where BoundedVec<(AccountId, ExtendedBalance), Bound>: Decode,

impl<AccountId, P> Decode for Assignment<AccountId, P>

where P: PerThing, AccountId: Decode, Vec<(AccountId, P)>: Decode,

impl<T> Decode for Compact<T>

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

impl<T, S> Decode for BoundedVec<T, S>

where T: Decode, S: Get<u32>,

impl<T, X> Decode for X

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

impl<VoterIndex, TargetIndex, P: PerThing> Decode for IndexAssignment<VoterIndex, TargetIndex, P>

where VoterIndex: Decode, Vec<(TargetIndex, P)>: Decode,