referrerpolicy=no-referrer-when-downgrade

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

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§

Source§

impl Decode for SlotLeasePeriodStart

Source§

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

Source§

impl Decode for StatementKind

Source§

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

Source§

impl Decode for VersionedLocatableAsset

Source§

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

Source§

impl Decode for AccountValidity

Source§

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

Source§

impl Decode for SlotRange

Source§

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

§

impl Decode for bool

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for f32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for f64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i8

§

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

§

impl Decode for i16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u8

§

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

§

impl Decode for u16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for ()

§

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

Source§

impl Decode for BasicParachainInherentData

Source§

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

Source§

impl Decode for InboundMessageId

Source§

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

Source§

impl Decode for MessagingStateSnapshot

Source§

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

Source§

impl Decode for RelayDispatchQueueRemainingCapacity

Source§

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

Source§

impl Decode for RelayChainState

Source§

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

Source§

impl Decode for UsedBandwidth

Source§

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

Source§

impl Decode for EcdsaSignature

Source§

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

Source§

impl Decode for EthereumAddress

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<EthereumAddress, Error>
where __CodecInputEdqy: 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 AbridgedHostConfiguration

§

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

§

impl Decode for AccessListEntry

§

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

§

impl Decode for AccountId20

§

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

§

impl Decode for AccountId32

§

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

§

impl Decode for AccountId32

§

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

§

impl Decode for AccountStatus

§

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

§

impl Decode for ActiveEraInfo

§

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

§

impl Decode for AdjustmentDirection

§

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

§

impl Decode for AllowedSlots

§

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

§

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

§

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

§

impl Decode for Asset

§

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

§

impl Decode for AssetFilter

§

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

§

impl Decode for AssetFilter

§

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

§

impl Decode for AssetId

§

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

§

impl Decode for AssetId

§

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

§

impl Decode for AssetId

§

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

§

impl Decode for AssetInstance

§

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

§

impl Decode for AssetInstance

§

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

§

impl Decode for AssetInstance

§

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

§

impl Decode for AssetStatus

§

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

§

impl Decode for AssetTransferFilter

§

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

§

impl Decode for Assets

§

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

§

impl Decode for Assignment

§

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

§

impl Decode for AsyncBackingParams

§

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

§

impl Decode for AuthorizationListEntry

§

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

§

impl Decode for AutoRenewalRecord

§

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

§

impl Decode for AvailabilityBitfield

§

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

§

impl Decode for BabeConfiguration

§

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

§

impl Decode for BabeConfigurationV1

§

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

§

impl Decode for BabeEpochConfiguration

§

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

§

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

§

impl Decode for BenchmarkBatchSplitResults

§

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

§

impl Decode for BenchmarkConfig

§

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

§

impl Decode for BenchmarkList

§

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

§

impl Decode for BenchmarkMetadata

§

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

§

impl Decode for BenchmarkParameter

§

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

§

impl Decode for BenchmarkResult

§

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

§

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

§

impl Decode for BlockData

§

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

§

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

§

impl Decode for BodyId

§

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

§

impl Decode for BodyPart

§

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

§

impl Decode for BridgeMessage

§

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

§

impl Decode for Byte

§

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

§

impl Decode for Bytes

§

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

§

impl Decode for Bytes

§

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

§

impl Decode for Bytes8

§

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

§

impl Decode for Bytes32

§

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

§

impl Decode for Bytes256

§

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

§

impl Decode for CallLog

§

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

§

impl Decode for CallTracerConfig

§

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

§

impl Decode for CallType

§

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

§

impl Decode for CandidateHash

§

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

§

impl Decode for CandidateUMPSignals

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CandidateUMPSignals, Error>
where __CodecInputEdqy: 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 ChunkIndex

§

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

§

impl Decode for ClaimQueueOffset

§

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

§

impl Decode for Code

§

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

§

impl Decode for CollationInfo

§

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

§

impl Decode for CollationInfoV1

§

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

§

impl Decode for CommittedCandidateReceiptError

§

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

§

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

§

impl Decode for CompletionStatus

§

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

§

impl Decode for ConsensusLog

§

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

§

impl Decode for ConsensusLog

§

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

§

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

§

impl Decode for ConversionError

§

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

§

impl Decode for CoreAssignment

§

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

§

impl Decode for CoreIndex

§

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

§

impl Decode for CoreInfo

§

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

§

impl Decode for CoreMask

§

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

§

impl Decode for CoreSelector

§

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

§

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

§

impl Decode for Data

§

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

§

impl Decode for DeriveJunction

§

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

§

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

§

impl Decode for DisputeOffenceKind

§

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

§

impl Decode for DisputeProof

§

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

§

impl Decode for DisputeResult

§

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

§

impl Decode for DisputeStatement

§

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

§

impl Decode for DisputeStatementSet

§

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

§

impl Decode for DisputesTimeSlot

§

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

§

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

§

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

§

impl Decode for Epoch

§

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

§

impl Decode for Era

§

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

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for Error

§

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

§

impl Decode for EthTransactError

§

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

§

impl Decode for ExecError

§

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

§

impl Decode for ExecReturnValue

§

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

§

impl Decode for ExecutionError

§

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

§

impl Decode for ExecutorParam

§

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

§

impl Decode for ExecutorParams

§

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

§

impl Decode for ExecutorParamsHash

§

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

§

impl Decode for ExecutorParamsPrepHash

§

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

§

impl Decode for ExtraFlags

§

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

§

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

§

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

§

impl Decode for Fungibility

§

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

§

impl Decode for Fungibility

§

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

§

impl Decode for Fungibility

§

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

§

impl Decode for GenericTransaction

§

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

§

impl Decode for GroupIndex

§

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

§

impl Decode for H32

§

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

§

impl Decode for H64

§

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

§

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

§

impl Decode for H264

§

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

§

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

§

impl Decode for H768

§

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

§

impl Decode for HashedMessage

§

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

§

impl Decode for Hint

§

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

§

impl Decode for HoldReason

§

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

§

impl Decode for HoldReason

§

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

§

impl Decode for HoldReason

§

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

§

impl Decode for HoldReason

§

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

§

impl Decode for HrmpChannel

§

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

§

impl Decode for HrmpOpenChannelRequest

§

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

§

impl Decode for HttpError

§

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

§

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

§

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

§

impl Decode for InputOrData

§

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

§

impl Decode for InstantiateReturnValue

§

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

§

impl Decode for InstructionError

§

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

§

impl Decode for InternalVersion

§

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

§

impl Decode for InvalidDisputeStatementKind

§

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

§

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

§

impl Decode for Junction

§

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

§

impl Decode for Junction

§

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

§

impl Decode for Junctions

§

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

§

impl Decode for Junctions

§

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

§

impl Decode for Junctions

§

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

§

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

§

impl Decode for Location

§

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

§

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

§

impl Decode for MembershipProof

§

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

§

impl Decode for MessageOrigin

§

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

§

impl Decode for MessageQueueChain

§

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

§

impl Decode for MessageSendError

§

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

§

impl Decode for Metadata

§

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

§

impl Decode for Metadata

§

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

§

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

§

impl Decode for MultiAssetFilter

§

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

§

impl Decode for MultiAssets

§

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

§

impl Decode for MultiLocation

§

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

§

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

§

impl Decode for NetworkId

§

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

§

impl Decode for NetworkId

§

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

§

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

§

impl Decode for NextEpochDescriptor

§

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

§

impl Decode for OccupiedCoreAssumption

§

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

§

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

§

impl Decode for OpaqueKeyOwnershipProof

§

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

§

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

§

impl Decode for Origin

§

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

§

impl Decode for OriginAliaser

§

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

§

impl Decode for OriginKind

§

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

§

impl Decode for OutboundHrmpChannelLimitations

§

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

§

impl Decode for Outcome

§

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

§

impl Decode for Outcome

§

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

§

impl Decode for Outcome

§

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

§

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

§

impl Decode for PalletInfo

§

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

§

impl Decode for PalletInfo

§

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

§

impl Decode for ParaGenesisArgs

§

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

§

impl Decode for ParaKind

§

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

§

impl Decode for ParaLifecycle

§

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

§

impl Decode for ParachainInherentData

§

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

§

impl Decode for ParathreadClaim

§

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

§

impl Decode for ParathreadEntry

§

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

§

impl Decode for PartsOf57600

§

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

§

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

§

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

§

impl Decode for PoolIoRecord

§

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

§

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

§

impl Decode for PreDigest

§

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

§

impl Decode for PrestateTrace

§

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

§

impl Decode for PrestateTraceInfo

§

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

§

impl Decode for PrestateTracerConfig

§

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

§

impl Decode for PrimaryPreDigest

§

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

§

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

§

impl Decode for PvfExecKind

§

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

§

impl Decode for PvfPrepKind

§

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

§

impl Decode for QueryResponseInfo

§

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

§

impl Decode for QueryResponseInfo

§

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

§

impl Decode for QueryResponseInfo

§

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

§

impl Decode for Reasons

§

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

§

impl Decode for RegionId

§

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

§

impl Decode for Releases

§

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

§

impl Decode for Response

§

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

§

impl Decode for Response

§

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

§

impl Decode for Response

§

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

§

impl Decode for ReturnFlags

§

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

§

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 RuntimeMetricLabel

§

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

§

impl Decode for RuntimeMetricLabels

§

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

§

impl Decode for RuntimeMetricOp

§

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

§

impl Decode for RuntimeMetricUpdate

§

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

§

impl Decode for RuntimeVersion

§

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

§

impl Decode for ScheduleItem

§

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

§

impl Decode for ScheduledCore

§

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

§

impl Decode for SecondaryPlainPreDigest

§

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

§

impl Decode for SecondaryVRFPreDigest

§

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

§

impl Decode for Select

§

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

§

impl Decode for SendError

§

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

§

impl Decode for ServiceQuality

§

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

§

impl Decode for SessionInfo

§

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

§

impl Decode for Sibling

§

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

§

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

§

impl Decode for SignatureResult

§

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

§

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

§

impl Decode for SlashingSpan

§

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

§

impl Decode for SlashingSpans

§

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

§

impl Decode for Slot

§

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

§

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

§

impl Decode for SlotDuration

§

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

§

fn decode_into<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<SlotDuration>, ) -> Result<DecodeFinished, 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 SolutionOrSnapshotSize

§

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

§

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

§

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

§

impl Decode for TracerType

§

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

§

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

§

impl Decode for Transaction7702Unsigned

§

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

§

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

§

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

§

impl Decode for TypeEip2930

§

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

§

impl Decode for TypeEip4844

§

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

§

impl Decode for TypeEip7702

§

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

§

impl Decode for TypeLegacy

§

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

§

impl Decode for U64

§

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

§

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

§

impl Decode for UMPSignal

§

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

§

impl Decode for UintAuthorityId

§

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

§

impl Decode for UnexpectedKind

§

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

§

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

§

impl Decode for UpgradeCheckSelect

§

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

§

impl Decode for UpgradeGoAhead

§

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

§

impl Decode for UpgradeRestriction

§

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

§

impl Decode for UpgradeStrategy

§

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

§

impl Decode for ValidDisputeStatementKind

§

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

§

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

§

impl Decode for ValidationCodeHash

§

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

§

impl Decode for ValidationParams

§

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

§

impl Decode for ValidationResult

§

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

§

impl Decode for ValidatorIndex

§

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

§

impl Decode for ValidatorPrefs

§

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

§

impl Decode for ValidityAttestation

§

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

§

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

§

impl Decode for VersionedAsset

§

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

§

impl Decode for VersionedAssetId

§

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

§

impl Decode for VersionedAssets

§

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

§

impl Decode for VersionedInteriorLocation

§

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

§

impl Decode for VersionedJunction

§

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

§

impl Decode for VersionedLocatableAccount

§

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

§

impl Decode for VersionedLocation

§

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

§

impl Decode for VersionedNetworkId

§

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

§

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

§

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

§

impl Decode for WildAsset

§

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

§

impl Decode for WildFungibility

§

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

§

impl Decode for WildFungibility

§

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

§

impl Decode for WildFungibility

§

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

§

impl Decode for WildMultiAsset

§

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

§

impl Decode for WithdrawReasons

§

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

§

impl Decode for XcmContext

§

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

§

impl Decode for XcmContext

§

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

§

impl Decode for XcmContext

§

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

§

impl Decode for XcmpMessageFormat

§

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

§

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<A, U, S> Decode for MigrationState<A, U, S>
where A: Decode, U: Decode, S: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<MigrationState<A, U, S>, Error>
where __CodecInputEdqy: Input,

Source§

impl<Account, Balance> Decode for ParaInfoV1<Account, Balance>
where Account: Decode, Balance: Decode,

Source§

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

Source§

impl<Account, Balance> Decode for ParaInfo<Account, Balance>
where Account: Decode, Balance: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ParaInfo<Account, Balance>, 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 ContributionRecord<AccountId>
where AccountId: Decode,

§

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

§

impl<AccountId> Decode for EraRewardPoints<AccountId>
where AccountId: Ord, BTreeMap<AccountId, u32>: Decode,

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RewardDestination<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> Decode for Support<AccountId>
where Vec<(AccountId, u128)>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Support<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, 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, BOuter, BInner> Decode for BoundedSupports<AccountId, BOuter, BInner>
where BOuter: Get<u32>, BInner: Get<u32>, BoundedVec<(AccountId, BoundedSupport<AccountId, BInner>), BOuter>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<BoundedSupports<AccountId, BOuter, BInner>, Error>
where __CodecInputEdqy: Input,

§

impl<AccountId, Balance> Decode for CandidateInfo<AccountId, Balance>
where AccountId: Decode, Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CandidateInfo<AccountId, Balance>, 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<AccountId, Balance> Decode for PagedExposure<AccountId, Balance>
where Balance: HasCompact + MaxEncodedLen, PagedExposureMetadata<Balance>: Decode, ExposurePage<AccountId, Balance>: Decode,

§

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

§

impl<AccountId, Balance> Decode for Proposal<AccountId, Balance>
where AccountId: Decode, Balance: Decode,

§

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

§

impl<AccountId, Balance> Decode for RegionRecord<AccountId, Balance>
where Option<AccountId>: Decode, Option<Balance>: Decode,

§

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

§

impl<AccountId, Balance> Decode for UnappliedSlash<AccountId, Balance>
where Balance: HasCompact + Decode, AccountId: Decode, Vec<(AccountId, Balance)>: Decode, Vec<AccountId>: Decode,

§

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

Source§

impl<AccountId, Balance, BlockNumber, LeasePeriod> Decode for FundInfo<AccountId, Balance, BlockNumber, LeasePeriod>
where AccountId: Decode, Balance: Decode, BlockNumber: Decode, LeasePeriod: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<FundInfo<AccountId, Balance, BlockNumber, LeasePeriod>, Error>
where __CodecInputEdqy: Input,

§

impl<AccountId, Balance, Solution> Decode for SignedSubmission<AccountId, Balance, Solution>
where Balance: HasCompact + Decode, AccountId: Decode, RawSolution<Solution>: Decode,

§

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

§

impl<AccountId, Bound> Decode for BoundedSupport<AccountId, Bound>
where Bound: Get<u32>, BoundedVec<(AccountId, u128), Bound>: Decode,

§

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

Source§

impl<AccountId, LeasePeriod> Decode for ParachainTemporarySlot<AccountId, LeasePeriod>
where AccountId: Decode, LeasePeriod: Decode, Option<LeasePeriod>: Decode,

Source§

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

§

impl<AccountId, MaxWinners, MaxBackersPerWinner> Decode for ReadySolution<AccountId, MaxWinners, MaxBackersPerWinner>
where AccountId: IdentifierT, MaxWinners: Get<u32>, MaxBackersPerWinner: Get<u32>, BoundedSupports<AccountId, MaxWinners, MaxBackersPerWinner>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ReadySolution<AccountId, MaxWinners, MaxBackersPerWinner>, Error>
where __CodecInputEdqy: Input,

§

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

§

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

§

impl<AccountId, VoterType> Decode for RoundSnapshot<AccountId, VoterType>
where Vec<VoterType>: Decode, Vec<AccountId>: Decode,

§

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

§

impl<Address, Call, Signature, Extension, const MAX_CALL_SIZE: usize> Decode for UncheckedExtrinsic<Address, Call, Signature, Extension, MAX_CALL_SIZE>
where Address: Decode, Signature: Decode, Call: DecodeWithMemTracking, Extension: Decode,

§

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

§

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

§

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

§

impl<Address, Signature, E> Decode for UncheckedExtrinsic<Address, Signature, E>
where E: EthExtra, UncheckedExtrinsic<Address, <<E as EthExtra>::Config as Config>::RuntimeCall, Signature, <E as EthExtra>::Extension>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<UncheckedExtrinsic<Address, Signature, E>, Error>
where __CodecInputEdqy: 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<AssetKind, AssetBalance, Beneficiary, BlockNumber, PaymentId> Decode for SpendStatus<AssetKind, AssetBalance, Beneficiary, BlockNumber, PaymentId>
where AssetKind: Decode, AssetBalance: Decode, Beneficiary: Decode, BlockNumber: Decode, PaymentState<PaymentId>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SpendStatus<AssetKind, AssetBalance, Beneficiary, BlockNumber, PaymentId>, Error>
where __CodecInputEdqy: Input,

§

impl<AuthorityId> Decode for ConsensusLog<AuthorityId>
where AuthorityId: Codec, Vec<AuthorityId>: Decode,

§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<Balance> Decode for FeeDetails<Balance>
where Option<InclusionFee<Balance>>: Decode, Balance: Decode,

§

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

§

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

§

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

§

impl<Balance> Decode for InstaPoolHistoryRecord<Balance>
where Option<Balance>: Decode,

§

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

§

impl<Balance> Decode for Judgement<Balance>
where Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq,

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<Balance> Decode for UnlockChunk<Balance>
where Balance: HasCompact + MaxEncodedLen,

§

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

§

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

§

impl<Balance, AccountId, DepositBalance> Decode for AssetDetails<Balance, AccountId, DepositBalance>
where AccountId: Decode, Balance: Decode, DepositBalance: Decode,

§

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

§

impl<Balance, AccountId, DepositBalance> Decode for OldAssetDetails<Balance, AccountId, DepositBalance>
where AccountId: Decode, Balance: Decode, DepositBalance: Decode,

§

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

§

impl<Balance, AccountId, IdField> Decode for RegistrarInfo<Balance, AccountId, IdField>
where Balance: Encode + Decode + Clone + Debug + Eq + PartialEq, AccountId: Encode + Decode + Clone + Debug + Eq + PartialEq, IdField: Encode + Decode + Clone + Debug + Default + Eq + PartialEq + TypeInfo + MaxEncodedLen,

§

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

§

impl<Balance, DepositBalance> Decode for Approval<Balance, DepositBalance>
where Balance: Decode, DepositBalance: Decode,

§

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

§

impl<Balance, DepositBalance, Extra, AccountId> Decode for AssetAccount<Balance, DepositBalance, Extra, AccountId>
where Balance: Decode, ExistenceReason<DepositBalance, AccountId>: Decode, Extra: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AssetAccount<Balance, DepositBalance, Extra, AccountId>, Error>
where __CodecInputEdqy: Input,

§

impl<Balance, MaxJudgements, IdentityInfo> Decode for Registration<Balance, MaxJudgements, IdentityInfo>
where Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq, MaxJudgements: Get<u32>, IdentityInfo: IdentityInformationProvider,

§

fn decode<I>( input: &mut I, ) -> Result<Registration<Balance, MaxJudgements, IdentityInfo>, Error>
where I: Input,

§

impl<Balance, RelayBlockNumber> Decode for SaleInfoRecord<Balance, RelayBlockNumber>
where RelayBlockNumber: Decode, Balance: Decode, Option<Balance>: Decode,

§

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

§

impl<Balance, Weight> Decode for RuntimeDispatchInfo<Balance, Weight>
where Weight: Decode, Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeDispatchInfo<Balance, Weight>, 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 ParachainBlockData<Block>
where Block: Block,

§

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

Source§

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

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<LastContribution<BlockNumber>, 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<BlockNumber> Decode for HostConfiguration<BlockNumber>
where BlockNumber: Decode, SchedulerParams<BlockNumber>: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<Bn> Decode for Phase<Bn>
where Bn: Decode, (bool, Bn): Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Phase<Bn>, 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<Call> Decode for Instruction<Call>

§

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

§

impl<Call> Decode for Instruction<Call>

§

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

§

impl<Call> Decode for Instruction<Call>

§

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

§

impl<Call> Decode for Xcm<Call>

§

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

§

impl<Call> Decode for Xcm<Call>

§

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

§

impl<Call> Decode for Xcm<Call>

§

fn decode<I>(input: &mut I) -> Result<Xcm<Call>, Error>
where I: 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<ConsumerIdentifier, MaxConsumers> Decode for RemoteLockedFungibleRecord<ConsumerIdentifier, MaxConsumers>
where MaxConsumers: Get<u32>, BoundedVec<(ConsumerIdentifier, u128), MaxConsumers>: Decode,

§

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

§

impl<DepositBalance, BoundedString> Decode for AssetMetadata<DepositBalance, BoundedString>
where DepositBalance: Decode, BoundedString: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AssetMetadata<DepositBalance, BoundedString>, Error>
where __CodecInputEdqy: 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<Event> Decode for CallDryRunEffects<Event>
where Vec<Event>: Decode,

§

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

§

impl<Event> Decode for XcmDryRunEffects<Event>
where Vec<Event>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<XcmDryRunEffects<Event>, 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<FieldLimit> Decode for IdentityInfo<FieldLimit>
where FieldLimit: Get<u32>, BoundedVec<(Data, Data), FieldLimit>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<IdentityInfo<FieldLimit>, Error>
where __CodecInputEdqy: 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<Gas> Decode for CallTrace<Gas>
where Gas: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CallTrace<Gas>, Error>
where __CodecInputEdqy: 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,

Source§

impl<H> Decode for Ancestor<H>
where Option<H>: Decode,

Source§

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

§

impl<H> Decode for BackedCandidate<H>
where CommittedCandidateReceiptV2<H>: Decode,

§

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

§

impl<H> Decode for CandidateDescriptorV2<H>
where H: Decode,

§

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

§

impl<H> Decode for CandidateEvent<H>
where CandidateReceiptV2<H>: Decode,

§

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

§

impl<H> Decode for CandidateReceiptV2<H>
where CandidateDescriptorV2<H>: Decode,

§

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

§

impl<H> Decode for CommittedCandidateReceiptV2<H>
where CandidateDescriptorV2<H>: Decode,

§

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

§

impl<H> Decode for ScrapedOnChainVotes<H>
where H: Encode + Decode, Vec<(CandidateReceiptV2<H>, Vec<(ValidatorIndex, ValidityAttestation)>)>: Decode,

§

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

§

impl<H> Decode for SigningContext<H>
where H: Decode,

§

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

§

impl<H, L> Decode for DataOrHash<H, L>
where H: Hash, L: FullLeaf + Decode,

§

fn decode<I>(value: &mut I) -> Result<DataOrHash<H, L>, 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<H, N> Decode for BackingState<H, N>
where Constraints<N>: Decode, Vec<CandidatePendingAvailability<H, N>>: Decode,

§

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

§

impl<H, N> Decode for CandidatePendingAvailability<H, N>
where CandidateDescriptorV2<H>: Decode, N: Decode,

§

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

§

impl<H, N> Decode for CandidatePendingAvailability<H, N>
where CandidateDescriptorV2<H>: Decode, N: Decode,

§

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

§

impl<H, N> Decode for CandidatePendingAvailability<H, N>
where CandidateDescriptorV2<H>: Decode, N: Decode,

§

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

§

impl<H, N> Decode for CoreState<H, N>
where OccupiedCore<H, N>: Decode,

§

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

§

impl<H, N> Decode for Equivocation<H, N>
where Equivocation<Public, Prevote<H, N>, Signature>: Decode, Equivocation<Public, Precommit<H, N>, Signature>: Decode,

§

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

§

impl<H, N> Decode for EquivocationProof<H, N>
where Equivocation<H, N>: Decode,

§

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

§

impl<H, N> Decode for Message<H, N>
where Prevote<H, N>: Decode, Precommit<H, N>: Decode, PrimaryPropose<H, N>: Decode,

§

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

§

impl<H, N> Decode for OccupiedCore<H, N>
where N: Decode, CandidateDescriptorV2<H>: Decode,

§

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

§

impl<H, N> Decode for Precommit<H, N>
where H: Decode, N: Decode,

§

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

§

impl<H, N> Decode for Prevote<H, N>
where H: Decode, N: Decode,

§

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

§

impl<H, N> Decode for PrimaryPropose<H, N>
where H: Decode, N: Decode,

§

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

§

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

§

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

§

impl<H, N, S, Id> Decode for CatchUp<H, N, S, Id>
where Vec<SignedPrevote<H, N, S, Id>>: Decode, Vec<SignedPrecommit<H, N, S, Id>>: Decode, H: Decode, N: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CatchUp<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, N, S, Id> Decode for Commit<H, N, S, Id>
where H: Decode, N: Decode, Vec<SignedPrecommit<H, N, S, Id>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Commit<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, N, S, Id> Decode for CompactCommit<H, N, S, Id>
where H: Decode, N: Decode, Vec<Precommit<H, N>>: Decode, Vec<(S, Id)>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CompactCommit<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, N, S, Id> Decode for HistoricalVotes<H, N, S, Id>
where Vec<SignedMessage<H, N, S, Id>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<HistoricalVotes<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, N, S, Id> Decode for SignedMessage<H, N, S, Id>
where Message<H, N>: Decode, S: Decode, Id: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SignedMessage<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, N, S, Id> Decode for SignedPrecommit<H, N, S, Id>
where Precommit<H, N>: Decode, S: Decode, Id: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SignedPrecommit<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, N, S, Id> Decode for SignedPrevote<H, N, S, Id>
where Prevote<H, N>: Decode, S: Decode, Id: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SignedPrevote<H, N, S, Id>, Error>
where __CodecInputEdqy: Input,

§

impl<H, T> Decode for Compact<H, T>
where T: Decode,

§

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

§

impl<HDR> Decode for InherentData<HDR>
where HDR: Header + Decode, Vec<BackedCandidate<<HDR as Header>::Hash>>: Decode,

§

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

§

impl<Hash> Decode for AncestryProof<Hash>
where Vec<Hash>: Decode, Vec<(u64, Hash)>: Decode,

§

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

§

impl<Hash> Decode for LeafProof<Hash>
where Vec<Hash>: Decode,

§

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

§

impl<Hash> Decode for RelayParentInfo<Hash>
where Hash: Decode,

§

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

§

impl<Hash, BlockNumber> Decode for AllowedRelayParentsTracker<Hash, BlockNumber>
where VecDeque<(Hash, Hash)>: Decode, BlockNumber: Decode,

§

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

§

impl<Hash, BlockNumber> Decode for AllowedRelayParentsTracker<Hash, BlockNumber>
where VecDeque<RelayParentInfo<Hash>>: Decode, BlockNumber: Decode,

§

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

§

impl<Header> Decode for GrandpaJustification<Header>
where Header: Header, Commit<<Header as Header>::Hash, <Header as Header>::Number, Signature, Public>: Decode, Vec<Header>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<GrandpaJustification<Header>, 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, Id> Decode for EquivocationProof<Header, Id>
where Id: Decode, Header: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<EquivocationProof<Header, Id>, 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> Decode for OutboundHrmpMessage<Id>
where Id: Decode,

§

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

§

impl<Id> Decode for PaymentState<Id>
where Id: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PaymentState<Id>, Error>
where __CodecInputEdqy: 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<Id, V, S> Decode for Equivocation<Id, V, S>
where Id: Decode, V: Decode, S: Decode, (V, S): Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Equivocation<Id, V, S>, 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> Decode for IndexedVec<K, V>
where Vec<V>: Decode, PhantomData<fn(K) -> K>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<IndexedVec<K, V>, Error>
where __CodecInputEdqy: 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,

Source§

impl<Message> Decode for AbridgedInboundMessagesCollection<Message>
where Message: InboundMessage, Vec<Message>: Decode, Vec<<Message as InboundMessage>::CompressedMessage>: Decode,

Source§

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

Source§

impl<Message> Decode for InboundMessagesCollection<Message>
where Message: InboundMessage, Vec<Message>: Decode,

Source§

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

§

impl<MessageOrigin> Decode for BookState<MessageOrigin>
where Option<Neighbours<MessageOrigin>>: Decode,

§

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

§

impl<MessageOrigin> Decode for Neighbours<MessageOrigin>
where MessageOrigin: Decode,

§

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

§

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

§

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

§

impl<N> Decode for AvailabilityBitfieldRecord<N>
where N: Decode,

§

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

§

impl<N> Decode for CandidateCommitments<N>
where N: Decode,

§

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

§

impl<N> Decode for ConsensusLog<N>
where N: Codec + Decode, ScheduledChange<N>: Decode,

§

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

§

impl<N> Decode for Constraints<N>
where N: Decode, Vec<N>: Decode, InboundHrmpLimitations<N>: Decode, Option<(N, ValidationCodeHash)>: Decode,

§

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

§

impl<N> Decode for DisputeState<N>
where N: Decode, Option<N>: Decode,

§

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

§

impl<N> Decode for GroupRotationInfo<N>
where N: Decode,

§

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

§

impl<N> Decode for InboundHrmpLimitations<N>
where Vec<N>: Decode,

§

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

§

impl<N> Decode for ParaPastCodeMeta<N>
where Vec<ReplacementTimes<N>>: Decode, Option<N>: Decode,

§

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

§

impl<N> Decode for ReplacementTimes<N>
where N: Decode,

§

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

§

impl<N> Decode for ScheduledChange<N>
where N: Decode,

§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SubstrateHeader<N, H>, Error>
where __CodecInputEdqy: 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>

§

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

§

impl<Payload, RealPayload> Decode for UncheckedSigned<Payload, RealPayload>
where Payload: Decode, PhantomData<RealPayload>: Decode,

§

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

§

impl<PoolAssetId> Decode for PoolInfo<PoolAssetId>
where PoolAssetId: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PoolInfo<PoolAssetId>, 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<R, Balance> Decode for ContractResult<R, Balance>
where StorageDeposit<Balance>: Decode, Result<R, DispatchError>: Decode,

§

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

§

impl<RelayBlockNumber> Decode for ConfigRecord<RelayBlockNumber>
where RelayBlockNumber: Decode,

§

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

§

impl<RelayBlockNumber, RelayBalance> Decode for OnDemandRevenueRecord<RelayBlockNumber, RelayBalance>
where RelayBlockNumber: Decode, RelayBalance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<OnDemandRevenueRecord<RelayBlockNumber, RelayBalance>, Error>
where __CodecInputEdqy: 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<ReserveIdentifier, Balance> Decode for ReserveData<ReserveIdentifier, Balance>
where ReserveIdentifier: Decode, Balance: Decode,

§

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

§

impl<RuntimeCall> Decode for VersionedXcm<RuntimeCall>

§

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

§

impl<S> Decode for RawSolution<S>
where S: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RawSolution<S>, 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<Size> Decode for ItemHeader<Size>
where Size: Decode,

§

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

§

impl<Size, HeapSize> Decode for Page<Size, HeapSize>
where Size: Into<u32> + Debug + Clone + Default + Decode, HeapSize: Get<Size>, BoundedVec<u8, IntoU32<HeapSize, Size>>: Decode,

§

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

§

impl<Store, Order> Decode for DecodedBits<Store, Order>
where Store: BitStore, Order: BitOrder,

§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

impl<T> Decode for Event<T>
where T: Config, <<T as Config>::Leaser as Leaser<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::LeasePeriod: Decode, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode, <T as Config>::AccountId: Decode, <<<T as Config>::Leaser as Leaser<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<<T as Config>::VestingSchedule as VestingSchedule<<T as Config>::AccountId>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<<T as Config>::Auctioneer as Auctioneer<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

impl<T> Decode for Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

§

impl<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 Vec<T>
where T: Decode,

§

fn decode<I>(input: &mut I) -> Result<Vec<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 AccountInfo<T>
where T: Config, AccountType<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AccountInfo<T>, Error>
where __CodecInputEdqy: 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 AuthorizedCodeHashAndExpiry<T>
where T: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AuthorizedCodeHashAndExpiry<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 Call<T>
where T: Config,

§

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

§

impl<T> Decode for Call<T>
where T: Config, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: Into<U256> + TryFrom<U256>, <<T as Config>::Time as Time>::Moment: Into<U256>, <T as Config>::Hash: IsType<H256>,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<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 ChargeAssetTxPayment<T>
where T: Config, Option<<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::AssetId>: Decode, <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::Balance: HasCompact,

§

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

§

impl<T> Decode for ChargeTransactionPayment<T>
where T: Config, <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::Balance: HasCompact,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ChargeTransactionPayment<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 ConfigOp<T>
where T: Default + Codec + Decode,

§

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

§

impl<T> Decode for ContractInfo<T>
where T: Config, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for Event<T>

§

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

§

impl<T> Decode for Event<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<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 Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

§

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

§

impl<T> Decode for Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

§

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

§

impl<T> Decode for Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

§

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

§

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

§

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

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, BoundedVec<u8, <T as Config>::MaxUsernameLength>: Decode, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

§

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

§

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

§

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

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: Decode, Option<<T as Config>::AccountId>: Decode, <<<T as Config>::Coretime as CoretimeInterface>::RelayChainBlockNumberProvider as BlockNumberProvider>::BlockNumber: Decode, <<T as Config>::Coretime as CoretimeInterface>::AccountId: Decode,

§

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

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Fungibles as Inspect<<T as Config>::AccountId>>::Balance: Decode, Option<<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::AssetId>: Decode,

§

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

§

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

§

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

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <T as Config>::PoolId: Decode, <T as Config>::PoolAssetId: Decode, <T as Config>::Balance: Decode, Vec<(<T as Config>::AssetKind, <T as Config>::Balance)>: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for Event<T>
where T: Config, Option<<T as Config>::AccountId>: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, Phase<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>: Decode,

§

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

§

impl<T> Decode for Event<T>
where T: Config, Vec<<T as Config>::AccountId>: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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 InitialPayment<T>
where T: Config, <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::LiquidityInfo: Decode, Imbalance<<<T as Config>::Fungibles as Inspect<<T as Config>::AccountId>>::AssetId, <<T as Config>::Fungibles as Inspect<<T as Config>::AccountId>>::Balance, <<T as Config>::Fungibles as Balanced<<T as Config>::AccountId>>::OnDropCredit, <<T as Config>::Fungibles as Balanced<<T as Config>::AccountId>>::OnDropDebt>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<InitialPayment<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 MaxChecking<T>
where T: Config, PhantomData<T>: Decode,

§

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

§

impl<T> Decode for Nominations<T>
where T: Config, BoundedVec<<T as Config>::AccountId, <<T as Config>::NominationsQuota as NominationsQuota<<T as Config>::CurrencyBalance>>::MaxNominations>: Decode,

§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Origin<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 RemoveUpgradeCooldownCostViewFunction<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RemoveUpgradeCooldownCostViewFunction<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 StakingLedger<T>
where T: Config, <T as Config>::AccountId: Decode, BoundedVec<UnlockChunk<<T as Config>::CurrencyBalance>, <T as Config>::MaxUnlockingChunks>: Decode, BoundedVec<u32, <T as Config>::HistoryDepth>: Decode, <T as Config>::CurrencyBalance: HasCompact, Option<<T as Config>::AccountId>: Default,

§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Static<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 UnstakeRequest<T>
where T: Config, BoundedVec<(<T as Config>::AccountId, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance), <T as Config>::BatchSize>: Decode, BoundedVec<u32, MaxChecking<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<UnstakeRequest<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 VerifySignatureDetails<T>
where T: Config, <T as Config>::Signature: Decode, <T as Config>::AccountId: Decode,

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<WrapperKeepOpaque<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, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T, I> Decode for Event<T, I>
where T: Config<I>, I: 'static, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <T as Config>::AccountId: Decode, <T as Config<I>>::AssetKind: Decode, <<T as Config<I>>::Paymaster as Pay>::Balance: Decode, <T as Config<I>>::Beneficiary: Decode, <<T as Config<I>>::BlockNumberProvider as BlockNumberProvider>::BlockNumber: Decode, <<T as Config<I>>::Paymaster as Pay>::Id: Decode,

§

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

§

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

§

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

§

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

§

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

§

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 BoundedVec<T, S>
where T: Decode, S: Get<u32>,

§

fn decode<I>(input: &mut I) -> Result<BoundedVec<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<Ticket, MAX> Decode for AuthorizedAliasesEntry<Ticket, MAX>
where MAX: Get<u32>, BoundedVec<OriginAliaser, MAX>: Decode, Ticket: Decode,

§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<IndexAssignment<VoterIndex, TargetIndex, P>, Error>
where __CodecInputEdqy: Input,

§

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 xcm_emulator::AggregateMessageOrigin

§

impl Decode for xcm_emulator::CumulusAggregateMessageOrigin

§

impl Decode for ProcessMessageError

§

impl Decode for UmpQueueId

§

impl Decode for WeightLimit

§

impl Decode for xcm_emulator::sr25519::vrf::VrfPreOutput

§

impl Decode for VrfProof

§

impl Decode for xcm_emulator::sr25519::vrf::VrfSignature

§

impl Decode for AbridgedHrmpChannel

§

impl Decode for xcm_emulator::Assets

§

impl Decode for BlockWeights

§

impl Decode for xcm_emulator::Digest

§

impl Decode for HeadData

§

impl Decode for HrmpChannelId

Source§

impl Decode for InboundMessagesData

§

impl Decode for xcm_emulator::Location

§

impl Decode for Id

§

impl Decode for xcm_emulator::ParachainInherentData

§

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<Balance> Decode for AccountData<Balance>
where Balance: Decode,

§

impl<H, N> Decode for PersistedValidationData<H, N>
where N: Decode, H: Decode,

Source§

impl<T> Decode for xcm_emulator::ParachainSystemCall<T>
where T: Config,

§

impl<T> Decode for xcm_emulator::TimestampCall<T>
where T: Config,

§

impl<T> Decode for PhantomData<T>

§

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

§

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

§

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