referrerpolicy=no-referrer-when-downgrade

Trait frame_election_provider_support::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> { ... }
}
Expand description

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.

Object Safety§

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

§

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

§

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

§

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

§

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 LogLevel

§

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

§

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

§

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

§

impl Decode for PaymentStatus

§

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

§

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

§

impl Decode for RingVerifierData

§

fn decode<R>(i: &mut R) -> Result<RingVerifierData, 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

§

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

§

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

§

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

§

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

§

impl Decode for StorageKind

§

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

§

impl Decode for 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 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 TrieError

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TrieError, 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 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 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 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 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 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 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 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 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 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 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 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 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<'a, T> Decode for Cow<'a, T>
where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode,

§

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

§

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

§

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>

§

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>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<LoneHoldConsideration<A, Fx, Rx, D, Fp>, 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, Extension> Decode for UncheckedExtrinsic<Address, Call, Signature, Extension>
where Address: Decode, Signature: Decode, Call: Decode, Extension: Decode,

§

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

§

impl<Address, Signature, Extension> Decode for Preamble<Address, Signature, Extension>
where Address: Decode, Signature: Decode, Extension: Decode,

§

fn decode<I>( input: &mut I, ) -> Result<Preamble<Address, Signature, Extension>, 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,

§

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

§

impl<C> Decode for ArkScaleProjective<Projective<C>>
where C: SWCurveConfig,

§

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

§

impl<C> Decode for ArkScaleProjective<Projective<C>>
where C: SWCurveConfig,

§

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

§

impl<C> Decode for ArkScaleProjective<Projective<C>>
where C: TECurveConfig,

§

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

§

impl<C> Decode for ArkScaleProjective<Projective<C>>
where C: TECurveConfig,

§

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

§

impl<C> Decode for PublicKey<C>
where C: AffineRepr,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl<C> Decode for VrfPreOut<C>
where C: AffineRepr,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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,

§

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, 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<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<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<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<P> Decode for VrfSignatureVec<P>
where P: EcVrfProof,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl<P, const N: usize> Decode for VrfSignature<P, N>
where P: EcVrfProof,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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 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 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 Crossing<T>
where T: Encode + Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Crossing<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 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 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 DeprecationInfo<T>
where T: Form, DeprecationStatus<T>: Decode, BTreeMap<u8, DeprecationStatus<T>>: Decode,

§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<DeprecationStatus<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>::AccountId: Decode, <T as Config>::Hash: 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 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 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, DeprecationInfo<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, DeprecationStatus<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, DeprecationInfo<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, DeprecationInfo<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<<T as Form>::String>: Decode, DeprecationStatus<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 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, DeprecationStatus<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, DeprecationStatus<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 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, DeprecationStatus<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 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 L: usize> Decode for ArkScaleLen<T, L>
where T: CanonicalDeserialize,

§

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

§

impl<T, const L: usize> Decode for ArkScaleLen<T, L>
where T: CanonicalDeserialize,

§

fn decode<I>(input: &mut I) -> Result<ArkScaleLen<T, L>, 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, const U: u8> Decode for ArkScale<T, U>
where T: CanonicalDeserialize,

§

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

§

impl<T, const U: u8> Decode for ArkScale<T, U>
where T: CanonicalDeserialize,

§

fn decode<I>(input: &mut I) -> Result<ArkScale<T, U>, Error>
where I: 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 D: u32> Decode for RingContext<D>

§

fn decode<R>(input: &mut R) -> Result<RingContext<D>, Error>
where R: 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,

Implementors§

§

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

source§

impl<VoterIndex, TargetIndex, P: PerThing> Decode for IndexAssignment<VoterIndex, TargetIndex, P>
where VoterIndex: Decode, Vec<(TargetIndex, P)>: Decode,