Trait Decode 

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

    // Provided methods
    fn decode_into<I>(
        input: &mut I,
        dst: &mut MaybeUninit<Self>,
    ) -> Result<DecodeFinished, Error>
       where I: Input { ... }
    fn skip<I>(input: &mut I) -> Result<(), Error>
       where I: Input { ... }
    fn encoded_fixed_size() -> Option<usize> { ... }
}

Trait that allows zero-copy read of value-references from slices in LE format.

Required Methods

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

where I: Input,

Attempt to deserialise the value from input.

Provided Methods

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

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

The default implementation will just call Decode::decode.

Safety

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

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

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

where I: Input,

Attempt to skip the encoded value from input.

The default implementation of this function is just calling Decode::decode. When possible, an implementation should provide a specialized implementation.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

If it returns Some(size) then all possible values of this type have the given size (in bytes) when encoded.

NOTE: A type with a fixed encoded size may return None.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Decode for HeaderChainError

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

where __CodecInputEdqy: Input,

impl Decode for MessagesOperatingMode

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

where __CodecInputEdqy: Input,

impl Decode for VerificationError

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

where __CodecInputEdqy: Input,

impl Decode for LaneState

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

where __CodecInputEdqy: Input,

impl Decode for BasicOperatingMode

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

where __CodecInputEdqy: Input,

impl Decode for OwnedBridgeModuleError

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

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

where __CodecInputEdqy: Input,

impl Decode for BridgeLocationsError

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

where __CodecInputEdqy: Input,

impl Decode for BridgeState

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

where __CodecInputEdqy: Input,

impl Decode for ChannelSignal

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

where __CodecInputEdqy: Input,

impl Decode for OutboundState

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

where __CodecInputEdqy: Input,

impl Decode for InboundState

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

where __CodecInputEdqy: Input,

impl Decode for AggregateMessageOrigin

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

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

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeMetadataDeprecated

Available on crate feature decode only.

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

where I: Input,

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for ProcessMessageError

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

where __CodecInputEdqy: Input,

impl Decode for Judgement

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

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

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for LanesManagerError

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

where __CodecInputEdqy: Input,

impl Decode for ReceptionConfirmationError

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Data

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

where I: Input,

impl Decode for MessageOrigin

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

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

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

where __CodecInputEdqy: Input,

impl Decode for XcmBlobMessageDispatchResult

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for CompactStatement

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

where I: Input,

impl Decode for ConsensusLog

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for UMPSignal

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

where __CodecInputEdqy: Input,

impl Decode for SlotLeasePeriodStart

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

where __CodecInputEdqy: Input,

impl Decode for StatementKind

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

where __CodecInputEdqy: Input,

impl Decode for VersionedLocatableAsset

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

where __CodecInputEdqy: Input,

impl Decode for AccountValidity

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

where __CodecInputEdqy: Input,

impl Decode for SlotRange

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Assignment

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

where __CodecInputEdqy: Input,

impl Decode for BlockState

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

where __CodecInputEdqy: Input,

impl Decode for Direction

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

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

where __CodecInputEdqy: Input,

impl Decode for BlockGapType

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

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

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

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

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

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

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

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

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

where I: Input,

impl Decode for Era

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

where I: Input,

impl Decode for DispatchError

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

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Value

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

where __CodecInputEdqy: Input,

impl Decode for Error

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

where __CodecInputEdqy: Input,

impl Decode for Unsupported

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

where I: Input,

impl Decode for VersionedAsset

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

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

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

where __CodecInputEdqy: 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 Junction

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

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

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

where I: Input,

impl Decode for MultiAssetFilter

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Fungibility

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Fungibility

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

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

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

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for f32

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for f64

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i8

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

where I: Input,

impl Decode for i16

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i32

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i64

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for i128

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u8

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

where I: Input,

impl Decode for u16

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u32

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u64

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for u128

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

where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Decode for ()

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

where I: Input,

impl Decode for String

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

where I: Input,

impl Decode for NonZero<i8>

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

where I: Input,

impl Decode for NonZero<i16>

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

where I: Input,

impl Decode for NonZero<i32>

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

where I: Input,

impl Decode for NonZero<i64>

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

where I: Input,

impl Decode for NonZero<i128>

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

where I: Input,

impl Decode for NonZero<u8>

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

where I: Input,

impl Decode for NonZero<u16>

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

where I: Input,

impl Decode for NonZero<u32>

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

where I: Input,

impl Decode for NonZero<u64>

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

where I: Input,

impl Decode for NonZero<u128>

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

where I: Input,

impl Decode for Duration

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

where I: Input,

impl Decode for AuthoritySet

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

where __CodecInputEdqy: Input,

impl Decode for HashedLaneId

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

where __CodecInputEdqy: Input,

impl Decode for LegacyLaneId

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

where __CodecInputEdqy: Input,

impl Decode for DeliveredMessages

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

where __CodecInputEdqy: Input,

impl Decode for InboundMessageDetails

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

where __CodecInputEdqy: Input,

impl Decode for OutboundLaneData

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

where __CodecInputEdqy: Input,

impl Decode for OutboundMessageDetails

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

where __CodecInputEdqy: Input,

impl Decode for UnrewardedRelayersState

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

where __CodecInputEdqy: Input,

impl Decode for BridgeState

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

where __CodecInputEdqy: Input,

impl Decode for BridgeId

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

where __CodecInputEdqy: Input,

impl Decode for Bytes

Available on crate feature bytes only.

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

where I: Input,

impl Decode for BasicParachainInherentData

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

where __CodecInputEdqy: Input,

impl Decode for InboundMessageId

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

where __CodecInputEdqy: Input,

impl Decode for InboundMessagesData

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

where __CodecInputEdqy: Input,

impl Decode for MessagingStateSnapshot

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

where __CodecInputEdqy: Input,

impl Decode for RelayDispatchQueueRemainingCapacity

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

where __CodecInputEdqy: Input,

impl Decode for RelayChainState

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

where __CodecInputEdqy: Input,

impl Decode for UsedBandwidth

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

where __CodecInputEdqy: Input,

impl Decode for QueueConfigData

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

where __CodecInputEdqy: Input,

impl Decode for InboundChannelDetails

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

where __CodecInputEdqy: Input,

impl Decode for OutboundChannelDetails

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

where __CodecInputEdqy: Input,

impl Decode for QueueConfigData

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

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

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

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

where __CodecInputEdqy: 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 DispatchInfo

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Disabled

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

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

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

where __CodecInputEdqy: Input,

impl Decode for BlockWeights

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

where __CodecInputEdqy: Input,

impl Decode for WeightsPerClass

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

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

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

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for BlockData

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

where __CodecInputEdqy: Input,

impl Decode for HeadData

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for AbridgedHostConfiguration

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

where __CodecInputEdqy: Input,

impl Decode for AbridgedHrmpChannel

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

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

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

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

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for EthereumAddress

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

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

where __CodecInputEdqy: Input,

impl Decode for H128

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

where I: Input,

impl Decode for H160

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

where I: Input,

impl Decode for H256

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

where I: Input,

impl Decode for H384

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

where I: Input,

impl Decode for H512

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

where I: Input,

impl Decode for H768

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

where I: Input,

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

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

where I: Input,

impl Decode for BlockAttributes

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Signature

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

where __CodecInputEdqy: Input,

impl Decode for Public

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

where __CodecInputEdqy: Input,

impl Decode for Signature

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

where __CodecInputEdqy: Input,

impl Decode for Public

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

where __CodecInputEdqy: Input,

impl Decode for Signature

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

where __CodecInputEdqy: Input,

impl Decode for BigUint

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

where __CodecInputEdqy: Input,

impl Decode for FixedI64

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

where __CodecInputEdqy: Input,

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Signature

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

where __CodecInputEdqy: Input,

impl Decode for MmrLeafVersion

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

where __CodecInputEdqy: Input,

impl Decode for Payload

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for VrfPreOutput

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

where R: Input,

impl Decode for VrfProof

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

where R: Input,

impl Decode for VrfSignature

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

where __CodecInputEdqy: Input,

impl Decode for OpaqueMetadata

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

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

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for MockCallU64

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

where __CodecInputEdqy: Input,

impl Decode for TestSignature

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

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

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

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for StorageProof

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

where __CodecInputEdqy: Input,

impl Decode for RuntimeVersion

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

where I: Input,

impl Decode for RuntimeDbWeight

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

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for Assets

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

where I: Input,

impl Decode for Location

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

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

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

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

where __CodecInputEdqy: Input,

impl Decode for OriginAliaser

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

where __CodecInputEdqy: Input,

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

where A0: Decode, B0: Decode, C0: Decode, D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

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

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

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

where __CodecInputEdqy: Input,

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

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

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

where __CodecInputEdqy: Input,

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

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

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

where __CodecInputEdqy: Input,

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

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

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

where __CodecInputEdqy: Input,

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

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

where Account: Decode, Balance: Decode,

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

where __CodecInputEdqy: Input,

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

where Account: Decode, Balance: Decode,

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

where PhantomData<AccountId>: Decode,

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

where __CodecInputEdqy: Input,

impl<AccountId> Decode for Owner<AccountId>

where PhantomData<AccountId>: Decode,

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

where __CodecInputEdqy: Input,

impl<AccountId> Decode for 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 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, 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 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 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 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 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,

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 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, BlockNumber, LeasePeriod> Decode for FundInfo<AccountId, Balance, BlockNumber, LeasePeriod>

where AccountId: Decode, Balance: Decode, BlockNumber: Decode, LeasePeriod: Decode,

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,

impl<AccountId, LeasePeriod> Decode for ParachainTemporarySlot<AccountId, LeasePeriod>

where AccountId: Decode, LeasePeriod: Decode, Option<LeasePeriod>: Decode,

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, MessagesProof, MessagesDeliveryProof> Decode for BridgeMessagesCall<AccountId, MessagesProof, MessagesDeliveryProof>

where AccountId: Decode, MessagesProof: Decode, MessagesDeliveryProof: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<BridgeMessagesCall<AccountId, MessagesProof, MessagesDeliveryProof>, 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, 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<AuthorityId> Decode for ConsensusLog<AuthorityId>

where AuthorityId: Codec, ValidatorSet<AuthorityId>: Decode,

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

where __CodecInputEdqy: Input,

impl<AuthorityId> Decode for ValidatorSet<AuthorityId>

where Vec<AuthorityId>: Decode,

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

where __CodecInputEdqy: Input,

impl<AuthoritySetCommitment> Decode for BeefyAuthoritySet<AuthoritySetCommitment>

where AuthoritySetCommitment: Decode,

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

where __CodecInputEdqy: Input,

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

where B0: Decode, C0: Decode, D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

impl<B> Decode for BlockAnnouncesHandshake<B>

where B: Block, <<B as Block>::Header as Header>::Number: Decode, <B as Block>::Hash: Decode,

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

where __CodecInputEdqy: Input,

impl<B> Decode for WarpProofRequest<B>

where B: Block, <B as Block>::Hash: Decode,

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

where __CodecInputEdqy: Input,

impl<B> Decode for BlockAndTimeDeadline<B>

where B: BlockNumberProvider, <B as BlockNumberProvider>::BlockNumber: Decode,

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

where __CodecInputEdqy: Input,

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

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

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

where __CodecInputEdqy: Input,

impl<B, V> Decode for BoundedStorageValue<B, V>

where V: Decode, PhantomData<B>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<BoundedStorageValue<B, V>, 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 AccountData<Balance>

where Balance: Decode,

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

where __CodecInputEdqy: Input,

impl<Balance> Decode for BalanceLock<Balance>

where Balance: Decode,

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

where __CodecInputEdqy: Input,

impl<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 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 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 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 AccountStatus<Balance>

where Balance: Decode,

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

where Block: Block,

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

where I: 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 GrandpaJustification<Block>

where Block: Block, GrandpaJustification<<Block as Block>::Header>: Decode, PhantomData<Block>: Decode,

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

where __CodecInputEdqy: Input,

impl<Block> Decode for WarpSyncFragment<Block>

where Block: Block, <Block as Block>::Header: Decode, GrandpaJustification<Block>: Decode,

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

where __CodecInputEdqy: Input,

impl<Block> Decode for WarpSyncProof<Block>

where Block: Block, Vec<WarpSyncFragment<Block>>: Decode,

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

where __CodecInputEdqy: Input,

impl<Block> Decode for SignedBlock<Block>

where Block: Decode,

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

where __CodecInputEdqy: Input,

impl<BlockNumber> Decode for DispatchTime<BlockNumber>

where BlockNumber: Decode,

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

where __CodecInputEdqy: Input,

impl<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 LastContribution<BlockNumber>

where BlockNumber: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<LastContribution<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 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 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<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, Hash, MerkleRoot, ExtraData> Decode for MmrLeaf<BlockNumber, Hash, MerkleRoot, ExtraData>

where BlockNumber: Decode, Hash: Decode, (BlockNumber, Hash): Decode, BeefyAuthoritySet<MerkleRoot>: Decode, ExtraData: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<MmrLeaf<BlockNumber, Hash, MerkleRoot, ExtraData>, 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<BridgedHeaderHash, Lane> Decode for FromBridgedChainMessagesProof<BridgedHeaderHash, Lane>

where BridgedHeaderHash: Decode, Lane: Decode,

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

where __CodecInputEdqy: Input,

impl<BridgedHeaderHash, LaneId> Decode for FromBridgedChainMessagesDeliveryProof<BridgedHeaderHash, LaneId>

where BridgedHeaderHash: Decode, LaneId: Decode,

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

where __CodecInputEdqy: Input,

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

where C0: Decode, D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

impl<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<ChainCall> Decode for EncodedOrDecodedCall<ChainCall>

where ChainCall: Decode,

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

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

where INPUT: Input,

impl<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<DispatchLevelResult> Decode for ReceptionResult<DispatchLevelResult>

where MessageDispatchResult<DispatchLevelResult>: Decode,

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

where __CodecInputEdqy: Input,

impl<DispatchLevelResult> Decode for MessageDispatchResult<DispatchLevelResult>

where DispatchLevelResult: Decode,

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

where __CodecInputEdqy: Input,

impl<DispatchLevelResult, LaneId> Decode for ReceivedMessages<DispatchLevelResult, LaneId>

where LaneId: Decode, Vec<(u64, ReceptionResult<DispatchLevelResult>)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ReceivedMessages<DispatchLevelResult, LaneId>, 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<FinalityProof, FinalityVerificationContext> Decode for HeaderFinalityInfo<FinalityProof, FinalityVerificationContext>

where FinalityProof: Decode, Option<FinalityVerificationContext>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<HeaderFinalityInfo<FinalityProof, FinalityVerificationContext>, 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<H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

where H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

impl<H> Decode for CandidateEvent<H>

where CandidateReceipt<H>: Decode,

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

where H: Header, Box<H>: Decode,

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

where __CodecInputEdqy: Input,

impl<H> Decode for Ancestor<H>

where Option<H>: Decode,

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

where __CodecInputEdqy: Input,

impl<H> Decode for BackedCandidate<H>

where CommittedCandidateReceipt<H>: Decode,

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

where __CodecInputEdqy: Input,

impl<H> Decode for CandidateDescriptor<H>

where H: Decode,

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

where __CodecInputEdqy: Input,

impl<H> Decode for CandidateReceipt<H>

where CandidateDescriptor<H>: Decode,

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

where __CodecInputEdqy: Input,

impl<H> Decode for CommittedCandidateReceipt<H>

where CandidateDescriptor<H>: Decode,

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

where __CodecInputEdqy: Input,

impl<H> Decode for ScrapedOnChainVotes<H>

where H: Encode + Decode, Vec<(CandidateReceipt<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> 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 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 BlockAnnounce<H>

where H: Decode,

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

where I: 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 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 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 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 State<H, N>

where Option<(H, N)>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<State<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 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 CandidateDescriptor<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 OccupiedCore<H, N>

where N: Decode, CandidateDescriptor<H>: Decode,

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

where __CodecInputEdqy: Input,

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

where N: Decode, H: Decode,

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

where ForkTree<H, N, PendingChange<H, N>>: Decode, Vec<PendingChange<H, N>>: Decode, AuthoritySetChanges<N>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AuthoritySet<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, 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, N, V> Decode for ForkTree<H, N, V>

where Vec<Node<H, N, V>>: Decode, Option<N>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ForkTree<H, N, V>, 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<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 RelayParentInfo<Hash>

where Hash: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RelayParentInfo<Hash>, 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, 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<Hash, Number> Decode for FromBlock<Hash, Number>

where Hash: Decode, Number: Decode,

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

where __CodecInputEdqy: Input,

impl<Hash, Number> Decode for HeaderId<Hash, Number>

where Number: Decode, Hash: Decode,

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

where __CodecInputEdqy: Input,

impl<Hash, Number> Decode for BlockRequest<Hash, Number>

where FromBlock<Hash, Number>: Decode,

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

where __CodecInputEdqy: Input,

impl<Header> Decode for BridgeGrandpaCall<Header>

where Header: Header, Box<Header>: Decode, GrandpaJustification<Header>: Decode, InitializationData<Header>: Decode,

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

where Header: Header, <Header as Header>::Hash: Decode, Vec<Header>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<FinalityProof<Header>, 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, Hash, Extrinsic> Decode for BlockData<Header, Hash, Extrinsic>

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

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

where __CodecInputEdqy: Input,

impl<Header, Hash, Extrinsic> Decode for BlockResponse<Header, Hash, Extrinsic>

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

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<BlockResponse<Header, Hash, 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<Header, Id, AncestryProof> Decode for ForkVotingProof<Header, Id, AncestryProof>

where Header: Header + Decode, Id: RuntimeAppPublic, VoteMessage<<Header as Header>::Number, Id, <Id as RuntimeAppPublic>::Signature>: Decode, AncestryProof: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ForkVotingProof<Header, Id, AncestryProof>, 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<I> Decode for HoldReason<I>

where I: 'static,

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

where Id: Decode,

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

where LaneId: Encode, MessageKey<LaneId>: Decode,

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

where __CodecInputEdqy: Input,

impl<LaneId> Decode for MessageKey<LaneId>

where LaneId: Encode + Decode,

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

where __CodecInputEdqy: Input,

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

where M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

impl<Message> Decode for ProvedLaneMessages<Message>

where Vec<Message>: Decode,

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

where __CodecInputEdqy: Input,

impl<Message> Decode for AbridgedInboundMessagesCollection<Message>

where Message: InboundMessage, Vec<Message>: Decode, Vec<<Message as InboundMessage>::CompressedMessage>: Decode,

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

where __CodecInputEdqy: Input,

impl<Message> Decode for InboundMessagesCollection<Message>

where Message: InboundMessage, Vec<Message>: Decode,

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 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 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 CandidateCommitments<N>

where N: Decode,

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

where N: Decode,

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

where Vec<(u64, N)>: Decode,

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

where __CodecInputEdqy: Input,

impl<N> Decode for BlockGap<N>

where N: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<BlockGap<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, S> Decode for VersionedFinalityProof<N, S>

where SignedCommitment<N, S>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<VersionedFinalityProof<N, S>, 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 StoredHeaderData<Number, Hash>

where Number: Decode, Hash: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StoredHeaderData<Number, Hash>, 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<Number, Id> Decode for FutureBlockVotingProof<Number, Id>

where Id: RuntimeAppPublic, VoteMessage<Number, Id, <Id as RuntimeAppPublic>::Signature>: Decode,

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

where __CodecInputEdqy: Input,

impl<Number, Id, Signature> Decode for DoubleVotingProof<Number, Id, Signature>

where VoteMessage<Number, Id, Signature>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<DoubleVotingProof<Number, Id, Signature>, Error>

where __CodecInputEdqy: Input,

impl<Number, Id, Signature> Decode for VoteMessage<Number, Id, Signature>

where Commitment<Number>: Decode, Id: Decode, Signature: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<VoteMessage<Number, Id, Signature>, Error>

where __CodecInputEdqy: Input,

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

where O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

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

where O: BitOrder, T: BitStore + Decode,

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

where I: Input,

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

where O: BitOrder, T: BitStore + Decode,

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

where I: Input,

impl<P0, Q0, R0> Decode for (P0, Q0, R0)

where P0: Decode, Q0: Decode, R0: Decode,

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

where INPUT: Input,

impl<P, S> Decode for GenericTransactionExtensionSchema<P, S>

where PhantomData<(P, S)>: Decode,

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

where __CodecInputEdqy: Input,

impl<Params, ReportedId> Decode for DeriveAndReportId<Params, ReportedId>

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

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

where __CodecInputEdqy: Input,

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

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

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

where __CodecInputEdqy: Input,

impl<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<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<RelayerId> Decode for InboundLaneData<RelayerId>

where VecDeque<UnrewardedRelayer<RelayerId>>: Decode,

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

where __CodecInputEdqy: Input,

impl<RelayerId> Decode for UnrewardedRelayer<RelayerId>

where RelayerId: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<UnrewardedRelayer<RelayerId>, 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<S> Decode for GenericTransactionExtension<S>

where S: TransactionExtensionSchema, <S as TransactionExtensionSchema>::Payload: Decode, Option<<S as TransactionExtensionSchema>::Implicit>: Default,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<GenericTransactionExtension<S>, 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<T> Decode for Cow<'_, T>

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

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

where I: Input,

impl<T> Decode for Option<T>

where T: Decode,

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

where I: Input,

impl<T> Decode for Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config,

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config,

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

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::AccountId: Decode, <T as Config>::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 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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <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 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 Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, 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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, 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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<T as Config>::MessageProcessor as ProcessMessage>::Origin: Decode, <T as Config>::Size: Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::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 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 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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config,

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config,

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<T as Config>::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,

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::AccountId: Decode, <<<T as Config>::VestingSchedule as VestingSchedule<<T as Config>::AccountId>>::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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::AccountId: Decode, <<<T as Config>::Auctioneer as Auctioneer<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

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

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: 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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<<T as Config>::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,

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<<T as Config>::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 Call<T>

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<<T as Config>::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 Call<T>

where T: Config,

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

where T: Config,

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

where __CodecInputEdqy: Input,

impl<T> Decode for Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, 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 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 Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<T as Config>::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 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 Error<T>

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

where __CodecInputEdqy: Input,

impl<T> Decode for Event<T>

where T: Config, <<<T as Config>::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 Call<T>

where T: Config,

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

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

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

where T: Decode,

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

where I: Input,

impl<T> Decode for Vec<T>

where T: Decode,

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

where I: Input,

impl<T> Decode for PhantomData<T>

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

where I: Input,

impl<T> Decode for Range<T>

where T: Decode,

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

where I: Input,

impl<T> Decode for RangeInclusive<T>

where T: Decode,

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

where I: Input,

impl<T> Decode for 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 PalletCallMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletConstantMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletErrorMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletEventMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for PalletMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for 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 SignedExtensionMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for StorageEntryMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for CustomMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for CustomValueMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for ExtrinsicMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for 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 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 RuntimeApiMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for RuntimeApiMethodMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for RuntimeApiMethodParamMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for SignedExtensionMetadata<T>

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

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

where __CodecInputEdqy: Input,

impl<T> Decode for 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 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 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 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 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 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 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 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 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 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 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 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 PerDispatchClass<T>

where T: Decode,

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

where T: Default + Decode,

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

where __CodecInputEdqy: Input,

impl<T> Decode for 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 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 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 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 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 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 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 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 PrevalidateAttests<T>

where PhantomData<fn(T)>: Decode,

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

where T: Decode,

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

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

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

where __CodecInputEdqy: Input,

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 Event<T, I>

where T: Config<I>, I: 'static, <T as Config<I>>::LaneId: Decode, ReceivedMessages<<<T as Config<I>>::MessageDispatch as MessageDispatch>::DispatchLevelResult, <T as Config<I>>::LaneId>: Decode,

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

where T: Config<I>, I: 'static,

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

where T: Config<I>, I: 'static, <<T as Config<<T as Config<I>>::BridgeMessagesPalletInstance>>::ThisChain as Chain>::Balance: Decode, <T as Config<<T as Config<I>>::BridgeMessagesPalletInstance>>::LaneId: Decode,

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

where __CodecInputEdqy: Input,

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

where T: Config<I>, I: 'static, InboundLaneData<<<T as Config<I>>::BridgedChain as Chain>::AccountId>: Decode,

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

where TBlockNumber: Decode,

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

where __CodecInputEdqy: Input,

impl<TBlockNumber, TSignature> Decode for SignedCommitment<TBlockNumber, TSignature>

where TBlockNumber: Decode + Clone, TSignature: Decode,

fn decode<I>( input: &mut I, ) -> Result<SignedCommitment<TBlockNumber, TSignature>, Error>

where I: Input,

impl<TBlockNumber, TSignatureAccumulator> Decode for SignedCommitmentWitness<TBlockNumber, TSignatureAccumulator>

where Commitment<TBlockNumber>: Decode, TSignatureAccumulator: Decode,

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

where __CodecInputEdqy: Input,

impl<ThisChain, LaneId> Decode for Bridge<ThisChain, LaneId>

where ThisChain: Chain, LaneId: LaneIdType + Decode, <ThisChain as Chain>::AccountId: Decode, <ThisChain as Chain>::Balance: Decode,

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

where __CodecInputEdqy: Input,

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,

Implementors

impl Decode for AssetTransferFilter

impl Decode for MaybeErrorCode

impl Decode for TransferType

impl Decode for VersionedAssetId

impl Decode for VersionedAssets

impl Decode for VersionedLocation

impl Decode for WeightLimit

impl Decode for emulated_integration_tests_common::macros::XcmPaymentApiError

impl Decode for emulated_integration_tests_common::impls::AggregateMessageOrigin

impl Decode for emulated_integration_tests_common::impls::Junction

impl Decode for emulated_integration_tests_common::impls::Junctions

impl Decode for emulated_integration_tests_common::impls::NetworkId

impl Decode for OriginKind

impl Decode for emulated_integration_tests_common::impls::Outcome

impl Decode for UmpQueueId

impl Decode for XcmBridgeHubCall

impl Decode for emulated_integration_tests_common::impls::XcmError

impl Decode for emulated_integration_tests_common::macros::AssetId

impl Decode for emulated_integration_tests_common::macros::Assets

impl Decode for emulated_integration_tests_common::macros::XcmContext

impl Decode for HrmpChannel

impl Decode for HrmpOpenChannelRequest

impl Decode for OptionBool

impl Decode for parity_scale_codec::compact::Compact<u8>

impl Decode for parity_scale_codec::compact::Compact<u16>

impl Decode for parity_scale_codec::compact::Compact<u32>

impl Decode for parity_scale_codec::compact::Compact<u64>

impl Decode for parity_scale_codec::compact::Compact<u128>

impl Decode for parity_scale_codec::compact::Compact<()>

impl Decode for AccountId32

impl Decode for emulated_integration_tests_common::impls::Asset

impl Decode for HrmpChannelId

impl Decode for emulated_integration_tests_common::impls::Location

impl Decode for Id

impl Decode for Weight

impl<AccountId> Decode for RawOrigin<AccountId>

where AccountId: Decode,

impl<Call> Decode for emulated_integration_tests_common::macros::Xcm<Call>

impl<RuntimeCall> Decode for VersionedXcm<RuntimeCall>

impl<T> Decode for emulated_integration_tests_common::impls::dmp::Call<T>

where T: Config,

impl<T> Decode for emulated_integration_tests_common::impls::hrmp::Call<T>

where T: Config,

impl<T> Decode for emulated_integration_tests_common::impls::hrmp::Error<T>

impl<T> Decode for emulated_integration_tests_common::impls::hrmp::Event<T>

where T: Config,

impl<T> Decode for parity_scale_codec::compact::Compact<T>

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

impl<T> Decode for DoubleEncoded<T>

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

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

impl<T, X> Decode for X

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