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

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

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

Required Methods§

source

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

Attempt to deserialise the value from input.

Provided Methods§

source

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.

source

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.

source

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl Decode for HeaderChainError

source§

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

source§

impl Decode for MessagesOperatingMode

source§

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

source§

impl Decode for VerificationError

source§

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

source§

impl Decode for BridgeParachainCall

source§

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

source§

impl Decode for RewardsAccountOwner

source§

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

source§

impl Decode for BasicOperatingMode

source§

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

source§

impl Decode for OwnedBridgeModuleError

source§

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

source§

impl Decode for Error

source§

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

source§

impl Decode for XcmBridgeHubRouterCall

source§

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

source§

impl Decode for XcmBlobMessageDispatchResult

source§

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

source§

impl Decode for ChannelSignal

source§

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

source§

impl Decode for OutboundState

source§

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

source§

impl Decode for InboundState

source§

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

source§

impl Decode for AggregateMessageOrigin

source§

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

source§

impl Decode for CumulusDigestItem

source§

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

source§

impl Decode for MessageSendError

source§

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

source§

impl Decode for ServiceQuality

source§

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

source§

impl Decode for RuntimeMetadata

source§

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

source§

impl Decode for RuntimeMetadataDeprecated

source§

impl Decode for StorageEntryModifier

source§

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

source§

impl Decode for StorageHasher

source§

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

source§

impl Decode for DispatchClass

source§

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

source§

impl Decode for Pays

source§

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

source§

impl Decode for Never

source§

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

source§

impl Decode for SteppedMigrationError

source§

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

source§

impl Decode for VersionedPostUpgradeData

source§

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

source§

impl Decode for ProcessMessageError

source§

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

source§

impl Decode for LookupError

source§

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

source§

impl Decode for BalanceStatus

source§

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

source§

impl Decode for PaymentStatus

source§

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

source§

impl Decode for Phase

source§

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

source§

impl Decode for AccountStatus

source§

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

source§

impl Decode for ConversionError

source§

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

source§

impl Decode for AdjustmentDirection

source§

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

source§

impl Decode for Reasons

source§

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

source§

impl Decode for CoreAssignment

source§

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

source§

impl Decode for CompletionStatus

source§

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

source§

impl Decode for Finality

source§

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

source§

impl Decode for ElectionCompute

source§

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

source§

impl Decode for Data

source§

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

source§

impl Decode for MessageOrigin

source§

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

source§

impl Decode for Event

source§

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

source§

impl Decode for Forcing

source§

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

source§

impl Decode for Event

source§

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

source§

impl Decode for Origin

source§

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

source§

impl Decode for VersionMigrationStage

source§

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

source§

impl Decode for XcmpMessageFormat

source§

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

source§

impl Decode for CompactStatement

source§

impl Decode for ConsensusLog

source§

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

source§

impl Decode for DisputeStatement

source§

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

source§

impl Decode for InvalidDisputeStatementKind

source§

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

source§

impl Decode for OccupiedCoreAssumption

source§

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

source§

impl Decode for PvfExecKind

source§

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

source§

impl Decode for PvfPrepKind

source§

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

source§

impl Decode for UpgradeGoAhead

source§

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

source§

impl Decode for UpgradeRestriction

source§

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

source§

impl Decode for ValidDisputeStatementKind

source§

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

source§

impl Decode for ValidityAttestation

source§

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

source§

impl Decode for ExecutorParam

source§

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

source§

impl Decode for RuntimeMetricOp

source§

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

source§

impl Decode for SlashingOffenceKind

source§

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

source§

impl Decode for SlotLeasePeriodStart

source§

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

source§

impl Decode for StatementKind

source§

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

source§

impl Decode for VersionedLocatableAsset

source§

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

source§

impl Decode for AccountValidity

source§

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

source§

impl Decode for SlotRange

source§

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

source§

impl Decode for DisputeLocation

source§

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

source§

impl Decode for DisputeResult

source§

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

source§

impl Decode for Origin

source§

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

source§

impl Decode for ParaKind

source§

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

source§

impl Decode for ParaLifecycle

source§

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

source§

impl Decode for SetGoAhead

source§

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

source§

impl Decode for Event

source§

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

source§

impl Decode for Assignment

source§

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

source§

impl Decode for BlockState

source§

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

source§

impl Decode for Direction

source§

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

source§

impl Decode for TypeDefPrimitive

source§

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

source§

impl Decode for ArithmeticError

source§

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

source§

impl Decode for NextConfigDescriptor

source§

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

source§

impl Decode for PreDigest

source§

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

source§

impl Decode for AllowedSlots

source§

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

source§

impl Decode for ConsensusLog

source§

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

source§

impl Decode for DeriveJunction

source§

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

source§

impl Decode for LogLevel

source§

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

source§

impl Decode for LogLevelFilter

source§

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

source§

impl Decode for Void

source§

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

source§

impl Decode for HttpError

source§

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

source§

impl Decode for HttpRequestStatus

source§

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

source§

impl Decode for StorageKind

source§

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

source§

impl Decode for EcdsaVerifyError

source§

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

source§

impl Decode for KillStorageResult

source§

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

source§

impl Decode for Error

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for ExtrinsicInclusionMode

source§

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

source§

impl Decode for MultiSignature

source§

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

source§

impl Decode for MultiSigner

source§

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

source§

impl Decode for TokenError

source§

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

source§

impl Decode for TransactionalError

source§

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

source§

impl Decode for DigestItem

source§

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

source§

impl Decode for Era

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for RuntimeString

source§

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

source§

impl Decode for InvalidTransaction

source§

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

source§

impl Decode for TransactionSource

source§

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

source§

impl Decode for TransactionValidityError

source§

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

source§

impl Decode for UnknownTransaction

source§

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

source§

impl Decode for DisableStrategy

source§

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

source§

impl Decode for ChildInfo

source§

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

source§

impl Decode for StateVersion

source§

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

source§

impl Decode for InherentError

source§

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

source§

impl Decode for WasmLevel

source§

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

source§

impl Decode for WasmValue

source§

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

source§

impl Decode for ReturnValue

source§

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

source§

impl Decode for Value

source§

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

source§

impl Decode for Error

source§

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

source§

impl Decode for Unsupported

source§

impl Decode for VersionedAsset

source§

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

source§

impl Decode for VersionedAssetId

source§

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

source§

impl Decode for VersionedAssets

source§

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

source§

impl Decode for VersionedInteriorLocation

source§

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

source§

impl Decode for VersionedJunction

source§

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

source§

impl Decode for VersionedLocation

source§

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

source§

impl Decode for VersionedNetworkId

source§

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

source§

impl Decode for VersionedResponse

source§

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

source§

impl Decode for BodyId

source§

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

source§

impl Decode for BodyPart

source§

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

source§

impl Decode for NetworkId

source§

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

source§

impl Decode for Response

source§

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

source§

impl Decode for WeightLimit

source§

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

source§

impl Decode for Junction

source§

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

source§

impl Decode for AssetId

source§

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

source§

impl Decode for AssetInstance

source§

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

source§

impl Decode for Fungibility

source§

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

source§

impl Decode for MultiAssetFilter

source§

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

source§

impl Decode for WildFungibility

source§

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

source§

impl Decode for WildMultiAsset

source§

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

source§

impl Decode for Junctions

source§

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

source§

impl Decode for Error

source§

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

source§

impl Decode for Outcome

source§

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

source§

impl Decode for SendError

source§

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

source§

impl Decode for AssetFilter

source§

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

source§

impl Decode for AssetInstance

source§

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

source§

impl Decode for Fungibility

source§

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

source§

impl Decode for WildAsset

source§

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

source§

impl Decode for WildFungibility

source§

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

source§

impl Decode for Response

source§

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

source§

impl Decode for bool

source§

impl Decode for f32

source§

impl Decode for f64

source§

impl Decode for i8

source§

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

source§

impl Decode for i16

source§

impl Decode for i32

source§

impl Decode for i64

source§

impl Decode for i128

source§

impl Decode for u8

source§

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

source§

impl Decode for u16

source§

impl Decode for u32

source§

impl Decode for u64

source§

impl Decode for u128

source§

impl Decode for ()

source§

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

source§

impl Decode for String

source§

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

source§

impl Decode for NonZero<i8>

source§

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

source§

impl Decode for NonZero<i16>

source§

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

source§

impl Decode for NonZero<i32>

source§

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

source§

impl Decode for NonZero<i64>

source§

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

source§

impl Decode for NonZero<i128>

source§

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

source§

impl Decode for NonZero<u8>

source§

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

source§

impl Decode for NonZero<u16>

source§

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

source§

impl Decode for NonZero<u32>

source§

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

source§

impl Decode for NonZero<u64>

source§

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

source§

impl Decode for NonZero<u128>

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for AuthoritySet

source§

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

source§

impl Decode for DeliveredMessages

source§

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

source§

impl Decode for InboundMessageDetails

source§

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

source§

impl Decode for LaneId

source§

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

source§

impl Decode for Message

source§

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

source§

impl Decode for MessageKey

source§

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

source§

impl Decode for OutboundLaneData

source§

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

source§

impl Decode for OutboundMessageDetails

source§

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

source§

impl Decode for UnrewardedRelayersState

source§

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

source§

impl Decode for BestParaHeadHash

source§

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

source§

impl Decode for ParaInfo

source§

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

source§

impl Decode for ParaStoredHeaderData

source§

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

source§

impl Decode for ParaHead

source§

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

source§

impl Decode for ParaHeadsProof

source§

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

source§

impl Decode for ParaId

source§

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

source§

impl Decode for RewardsAccountParams

source§

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

source§

impl Decode for BridgeState

source§

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

source§

impl Decode for Bytes

source§

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

source§

impl Decode for MessagingStateSnapshot

source§

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

source§

impl Decode for RelayDispatchQueueRemainingCapacity

source§

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

source§

impl Decode for RelayChainState

source§

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

source§

impl Decode for QueueConfigData

source§

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

source§

impl Decode for InboundChannelDetails

source§

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

source§

impl Decode for OutboundChannelDetails

source§

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

source§

impl Decode for QueueConfigData

source§

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

source§

impl Decode for CollationInfo

source§

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

source§

impl Decode for CollationInfoV1

source§

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

source§

impl Decode for MessageQueueChain

source§

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

source§

impl Decode for ParachainInherentData

source§

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

source§

impl Decode for OpaqueMetadata

source§

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

source§

impl Decode for RuntimeMetadataPrefixed

source§

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

source§

impl Decode for RuntimeMetadataV14

source§

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

source§

impl Decode for RuntimeMetadataV15

source§

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

source§

impl Decode for DispatchInfo

source§

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

source§

impl Decode for PostDispatchInfo

source§

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

source§

impl Decode for PalletId

source§

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

source§

impl Decode for CrateVersion

source§

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

source§

impl Decode for StorageVersion

source§

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

source§

impl Decode for StorageInfo

source§

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

source§

impl Decode for WithdrawReasons

source§

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

source§

impl Decode for BlockLength

source§

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

source§

impl Decode for BlockWeights

source§

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

source§

impl Decode for WeightsPerClass

source§

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

source§

impl Decode for LastRuntimeUpgradeInfo

source§

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

source§

impl Decode for ExtraFlags

source§

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

source§

impl Decode for CoreMask

source§

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

source§

impl Decode for AllowedRenewalId

source§

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

source§

impl Decode for LeaseRecordItem

source§

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

source§

impl Decode for PoolIoRecord

source§

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

source§

impl Decode for RegionId

source§

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

source§

impl Decode for ScheduleItem

source§

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

source§

impl Decode for StatusRecord

source§

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

source§

impl Decode for SolutionOrSnapshotSize

source§

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

source§

impl Decode for SlashingSpans

source§

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

source§

impl Decode for ActiveEraInfo

source§

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

source§

impl Decode for ValidatorPrefs

source§

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

source§

impl Decode for CandidateHash

source§

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

source§

impl Decode for BlockData

source§

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

source§

impl Decode for HeadData

source§

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

source§

impl Decode for Sibling

source§

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

source§

impl Decode for ValidationCode

source§

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

source§

impl Decode for ValidationCodeHash

source§

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

source§

impl Decode for ValidationParams

source§

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

source§

impl Decode for ValidationResult

source§

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

source§

impl Decode for AsyncBackingParams

source§

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

source§

impl Decode for OutboundHrmpChannelLimitations

source§

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

source§

impl Decode for ExecutorParams

source§

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

source§

impl Decode for ExecutorParamsHash

source§

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

source§

impl Decode for RuntimeMetricLabel

source§

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

source§

impl Decode for RuntimeMetricLabels

source§

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

source§

impl Decode for RuntimeMetricUpdate

source§

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

source§

impl Decode for DisputeProof

source§

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

source§

impl Decode for DisputesTimeSlot

source§

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

source§

impl Decode for OpaqueKeyOwnershipProof

source§

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

source§

impl Decode for PendingSlashes

source§

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

source§

impl Decode for AbridgedHostConfiguration

source§

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

source§

impl Decode for AbridgedHrmpChannel

source§

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

source§

impl Decode for AvailabilityBitfield

source§

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

source§

impl Decode for CoreIndex

source§

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

source§

impl Decode for DisputeStatementSet

source§

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

source§

impl Decode for GroupIndex

source§

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

source§

impl Decode for ParathreadClaim

source§

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

source§

impl Decode for ParathreadEntry

source§

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

source§

impl Decode for PvfCheckStatement

source§

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

source§

impl Decode for ScheduledCore

source§

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

source§

impl Decode for SessionInfo

source§

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

source§

impl Decode for ValidatorIndex

source§

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

source§

impl Decode for ApprovalVotingParams

source§

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

source§

impl Decode for EcdsaSignature

source§

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

source§

impl Decode for EthereumAddress

source§

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

source§

impl Decode for PartsOf57600

source§

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

source§

impl Decode for CoreAffinityCount

source§

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

source§

impl Decode for ParaGenesisArgs

source§

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

source§

impl Decode for H128

source§

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

source§

impl Decode for H160

source§

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

source§

impl Decode for H256

source§

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

source§

impl Decode for H384

source§

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

source§

impl Decode for H512

source§

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

source§

impl Decode for H768

source§

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

source§

impl Decode for U128

source§

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

source§

impl Decode for U256

source§

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

source§

impl Decode for U512

source§

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

source§

impl Decode for Roles

source§

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

source§

impl Decode for BlockAttributes

source§

impl Decode for PortableRegistry

source§

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

source§

impl Decode for PortableType

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for BigUint

source§

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

source§

impl Decode for FixedI64

source§

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

source§

impl Decode for FixedI128

source§

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

source§

impl Decode for FixedU64

source§

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

source§

impl Decode for FixedU128

source§

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

source§

impl Decode for PerU16

source§

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

source§

impl Decode for Perbill

source§

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

source§

impl Decode for Percent

source§

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

source§

impl Decode for Permill

source§

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

source§

impl Decode for Perquintill

source§

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

source§

impl Decode for NextEpochDescriptor

source§

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

source§

impl Decode for PrimaryPreDigest

source§

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

source§

impl Decode for SecondaryPlainPreDigest

source§

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

source§

impl Decode for SecondaryVRFPreDigest

source§

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

source§

impl Decode for BabeConfiguration

source§

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

source§

impl Decode for BabeConfigurationV1

source§

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

source§

impl Decode for BabeEpochConfiguration

source§

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

source§

impl Decode for Epoch

source§

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

source§

impl Decode for OpaqueKeyOwnershipProof

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for MmrLeafVersion

source§

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

source§

impl Decode for Payload

source§

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

source§

impl Decode for OpaqueKeyOwnershipProof

source§

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

source§

impl Decode for OpaqueKeyOwnershipProof

source§

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

source§

impl Decode for Slot

source§

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

source§

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

source§

impl Decode for SlotDuration

source§

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

source§

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

source§

impl Decode for CryptoTypeId

source§

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

source§

impl Decode for KeyTypeId

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for HttpRequestId

source§

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

source§

impl Decode for OpaqueMultiaddr

source§

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

source§

impl Decode for OpaqueNetworkState

source§

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

source§

impl Decode for Timestamp

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for VrfPreOutput

source§

impl Decode for VrfProof

source§

impl Decode for VrfSignature

source§

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

source§

impl Decode for OpaqueMetadata

source§

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

source§

impl Decode for OpaquePeerId

source§

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

source§

impl Decode for MultiRemovalResults

source§

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

source§

impl Decode for CheckInherentsResult

source§

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

source§

impl Decode for InherentData

source§

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

source§

impl Decode for EncodableOpaqueLeaf

source§

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

source§

impl Decode for ElectionScore

source§

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

source§

impl Decode for Digest

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for Time

source§

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

source§

impl Decode for AnySignature

source§

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

source§

impl Decode for Justifications

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for OpaqueExtrinsic

source§

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

source§

impl Decode for TestSignature

source§

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

source§

impl Decode for UintAuthorityId

source§

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

source§

impl Decode for BadOrigin

source§

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

source§

impl Decode for LookupError

source§

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

source§

impl Decode for ValidTransaction

source§

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

source§

impl Decode for MembershipProof

source§

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

source§

impl Decode for ChildTrieParentKeyId

source§

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

source§

impl Decode for StorageData

source§

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

source§

impl Decode for StorageKey

source§

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

source§

impl Decode for TrackedStorageKey

source§

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

source§

impl Decode for Timestamp

source§

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

source§

impl Decode for WasmEntryAttributes

source§

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

source§

impl Decode for WasmFieldName

source§

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

source§

impl Decode for WasmFields

source§

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

source§

impl Decode for WasmMetadata

source§

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

source§

impl Decode for WasmValuesSet

source§

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

source§

impl Decode for CompactProof

source§

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

source§

impl Decode for StorageProof

source§

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

source§

impl Decode for RuntimeVersion

source§

impl Decode for RuntimeDbWeight

source§

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

source§

impl Decode for BridgeMessage

source§

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

source§

impl Decode for MultiAsset

source§

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

source§

impl Decode for MultiAssets

source§

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

source§

impl Decode for MultiLocation

source§

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

source§

impl Decode for Asset

source§

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

source§

impl Decode for AssetId

source§

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

source§

impl Decode for Assets

source§

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

source§

impl Decode for PalletInfo

source§

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

source§

impl Decode for QueryResponseInfo

source§

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

source§

impl Decode for XcmContext

source§

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

source§

impl<'a, T> Decode for Cow<'a, T>
where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<AccountId> Decode for RawOrigin<AccountId>
where AccountId: Decode,

source§

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

source§

impl<AccountId> Decode for RewardDestination<AccountId>
where AccountId: Decode,

source§

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

source§

impl<AccountId> Decode for ContributionRecord<AccountId>
where AccountId: Decode,

source§

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

source§

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

source§

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

source§

impl<AccountId> Decode for StakedAssignment<AccountId>
where AccountId: Decode, Vec<(AccountId, u128)>: Decode,

source§

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

source§

impl<AccountId> Decode for Support<AccountId>
where Vec<(AccountId, u128)>: Decode,

source§

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

source§

impl<AccountId, AccountIndex> Decode for MultiAddress<AccountId, AccountIndex>
where AccountId: Decode, AccountIndex: HasCompact,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<AccountId, Balance> Decode for PagedExposure<AccountId, Balance>
where Balance: HasCompact + MaxEncodedLen, PagedExposureMetadata<Balance>: Decode, ExposurePage<AccountId, Balance>: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<AccountId, Balance> Decode for Exposure<AccountId, Balance>
where Balance: HasCompact, Vec<IndividualExposure<AccountId, Balance>>: Decode,

source§

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

source§

impl<AccountId, Balance> Decode for ExposurePage<AccountId, Balance>
where Balance: HasCompact, Vec<IndividualExposure<AccountId, Balance>>: Decode,

source§

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

source§

impl<AccountId, Balance> Decode for IndividualExposure<AccountId, Balance>
where Balance: HasCompact, AccountId: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<AccountId, MaxWinners> Decode for ReadySolution<AccountId, MaxWinners>
where AccountId: IdentifierT, MaxWinners: Get<u32>, BoundedVec<(AccountId, Support<AccountId>), MaxWinners>: Decode,

source§

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

source§

impl<AccountId, MessagesProof, MessagesDeliveryProof> Decode for BridgeMessagesCall<AccountId, MessagesProof, MessagesDeliveryProof>
where AccountId: Decode, MessagesProof: Decode, MessagesDeliveryProof: Decode,

source§

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

source§

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

source§

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

source§

impl<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra>
where Address: Decode, Signature: Decode, Call: Decode, Extra: SignedExtension,

source§

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

source§

impl<AssetId> Decode for NativeOrWithId<AssetId>
where AssetId: Ord + Decode,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<AuthorityId> Decode for ValidatorSet<AuthorityId>
where Vec<AuthorityId>: Decode,

source§

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

source§

impl<AuthoritySetCommitment> Decode for BeefyAuthoritySet<AuthoritySetCommitment>
where AuthoritySetCommitment: Decode,

source§

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

source§

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,

source§

impl<B> Decode for ParachainBlockData<B>
where B: Block, <B as Block>::Header: Decode, Vec<<B as Block>::Extrinsic>: Decode,

source§

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

source§

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

source§

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

source§

impl<B> Decode for WarpProofRequest<B>
where B: Block, <B as Block>::Hash: Decode,

source§

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

source§

impl<B> Decode for BlockAndTimeDeadline<B>

source§

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

source§

impl<B, V> Decode for BoundedStorageValue<B, V>
where V: Decode, PhantomData<B>: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

impl<Block> Decode for BlockId<Block>
where Block: Block, <Block as Block>::Hash: Decode, <<Block as Block>::Header as Header>::Number: Decode,

source§

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

source§

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

source§

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

source§

impl<Block> Decode for WarpSyncFragment<Block>
where Block: Block, <Block as Block>::Header: Decode, GrandpaJustification<Block>: Decode,

source§

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

source§

impl<Block> Decode for WarpSyncProof<Block>
where Block: Block, Vec<WarpSyncFragment<Block>>: Decode,

source§

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

source§

impl<Block> Decode for SignedBlock<Block>
where Block: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<BlockNumber, Balance> Decode for Registration<BlockNumber, Balance>
where BlockNumber: Decode, Balance: Decode,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<BridgedHeaderHash> Decode for FromBridgedChainMessagesDeliveryProof<BridgedHeaderHash>
where BridgedHeaderHash: Decode,

source§

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

source§

impl<BridgedHeaderHash> Decode for FromBridgedChainMessagesProof<BridgedHeaderHash>
where BridgedHeaderHash: Decode,

source§

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

source§

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,

source§

impl<Call> Decode for Instruction<Call>

source§

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

source§

impl<Call> Decode for Xcm<Call>

source§

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

source§

impl<Call, Extra> Decode for TestXt<Call, Extra>
where Option<(u64, Extra)>: Decode, Call: Decode,

source§

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

source§

impl<ChainCall> Decode for EncodedOrDecodedCall<ChainCall>
where ChainCall: Decode,

source§

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

source§

impl<ConsumerIdentifier, MaxConsumers> Decode for RemoteLockedFungibleRecord<ConsumerIdentifier, MaxConsumers>
where MaxConsumers: Get<u32>, BoundedVec<(ConsumerIdentifier, u128), MaxConsumers>: Decode,

source§

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

source§

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,

source§

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

source§

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

source§

impl<DispatchLevelResult> Decode for ReceivalResult<DispatchLevelResult>
where MessageDispatchResult<DispatchLevelResult>: Decode,

source§

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

source§

impl<DispatchLevelResult> Decode for ReceivedMessages<DispatchLevelResult>
where Vec<(u64, ReceivalResult<DispatchLevelResult>)>: Decode,

source§

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

source§

impl<DispatchLevelResult> Decode for MessageDispatchResult<DispatchLevelResult>
where DispatchLevelResult: Decode,

source§

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

source§

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,

source§

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

source§

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

source§

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,

source§

impl<FieldLimit> Decode for IdentityInfo<FieldLimit>
where FieldLimit: Get<u32>, BoundedVec<(Data, Data), FieldLimit>: Decode,

source§

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

source§

impl<FinalityProof, FinalityVerificationContext> Decode for HeaderFinalityInfo<FinalityProof, FinalityVerificationContext>
where FinalityProof: Decode, Option<FinalityVerificationContext>: Decode,

source§

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

source§

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,

source§

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,

source§

impl<H> Decode for CandidateEvent<H>

source§

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

source§

impl<H> Decode for InitializationData<H>
where H: Header, Box<H>: Decode,

source§

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

source§

impl<H> Decode for BackedCandidate<H>

source§

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

source§

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

source§

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

source§

impl<H> Decode for CandidateReceipt<H>

source§

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

source§

impl<H> Decode for CommittedCandidateReceipt<H>

source§

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

source§

impl<H> Decode for ScrapedOnChainVotes<H>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<Hash, Number> Decode for FromBlock<Hash, Number>
where Hash: Decode, Number: Decode,

source§

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

source§

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

source§

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

source§

impl<Hash, Number> Decode for BlockRequest<Hash, Number>
where FromBlock<Hash, Number>: Decode,

source§

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

source§

impl<Header> Decode for BridgeGrandpaCall<Header>
where Header: Header, Box<Header>: Decode, GrandpaJustification<Header>: Decode, InitializationData<Header>: Decode,

source§

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

source§

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

source§

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

source§

impl<Header> Decode for FinalityProof<Header>
where Header: Header, <Header as Header>::Hash: Decode, Vec<Header>: Decode,

source§

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

source§

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

source§

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

source§

impl<Header, Extrinsic> Decode for Block<Header, Extrinsic>
where Header: Decode, Vec<Extrinsic>: Decode,

source§

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

source§

impl<Header, Hash, Extrinsic> Decode for BlockData<Header, Hash, Extrinsic>
where Hash: Decode, Option<Header>: Decode, Option<Vec<Extrinsic>>: Decode,

source§

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

source§

impl<Header, Hash, Extrinsic> Decode for BlockResponse<Header, Hash, Extrinsic>
where Vec<BlockData<Header, Hash, Extrinsic>>: Decode,

source§

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

source§

impl<Header, Id> Decode for EquivocationProof<Header, Id>
where Id: Decode, Header: Decode,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

impl<Id, Balance> Decode for IdAmount<Id, Balance>
where Id: Decode, Balance: Decode,

source§

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

source§

impl<Id, V, S> Decode for Equivocation<Id, V, S>
where Id: Decode, V: Decode, S: Decode, (V, S): Decode,

source§

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

source§

impl<Info> Decode for DispatchErrorWithPostInfo<Info>
where Info: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable,

source§

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

source§

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,

source§

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,

source§

impl<K, V> Decode for BTreeMap<K, V>
where K: Decode + Ord, V: Decode,

source§

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

source§

impl<K, V> Decode for IndexedVec<K, V>
where Vec<V>: Decode, PhantomData<fn(_: K) -> K>: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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,

source§

impl<Message> Decode for ProvedLaneMessages<Message>
where Vec<Message>: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<N> Decode for CoreOccupied<N>
where ParasEntry<N>: Decode,

source§

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

source§

impl<N> Decode for ConsensusLog<N>

source§

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

source§

impl<N> Decode for Constraints<N>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<N> Decode for ParaPastCodeMeta<N>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<N> Decode for AuthoritySetChanges<N>
where Vec<(u64, N)>: Decode,

source§

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

source§

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

source§

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

source§

impl<N, S> Decode for VersionedFinalityProof<N, S>
where SignedCommitment<N, S>: Decode,

source§

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

source§

impl<Nonce, AccountData> Decode for AccountInfo<Nonce, AccountData>
where Nonce: Decode, AccountData: Decode,

source§

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

source§

impl<Number, Hash> Decode for StoredHeaderData<Number, Hash>
where Number: Decode, Hash: Decode,

source§

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

source§

impl<Number, Hash> Decode for Header<Number, Hash>
where Number: Copy + Into<U256> + TryFrom<U256> + HasCompact, Hash: Hash, <Hash as Hash>::Output: Decode,

source§

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

source§

impl<Number, Id, Signature> Decode for EquivocationProof<Number, Id, Signature>
where VoteMessage<Number, Id, Signature>: Decode,

source§

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

source§

impl<Number, Id, Signature> Decode for VoteMessage<Number, Id, Signature>
where Commitment<Number>: Decode, Id: Decode, Signature: Decode,

source§

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

source§

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

source§

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

source§

impl<O, T> Decode for BitBox<T, O>
where O: BitOrder, T: BitStore + Decode,

source§

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

source§

impl<O, T> Decode for BitVec<T, O>
where O: BitOrder, T: BitStore + Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<R0> Decode for (R0,)
where R0: Decode,

source§

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

source§

impl<RelayerId> Decode for InboundLaneData<RelayerId>
where VecDeque<UnrewardedRelayer<RelayerId>>: Decode,

source§

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

source§

impl<RelayerId> Decode for UnrewardedRelayer<RelayerId>
where RelayerId: Decode,

source§

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

source§

impl<Reporter, Offender> Decode for OffenceDetails<Reporter, Offender>
where Offender: Decode, Vec<Reporter>: Decode,

source§

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

source§

impl<ReserveIdentifier, Balance> Decode for ReserveData<ReserveIdentifier, Balance>
where ReserveIdentifier: Decode, Balance: Decode,

source§

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

source§

impl<Runtime, GrandpaInstance, Msgs, Refund, Priority, Id> Decode for RefundBridgedGrandpaMessages<Runtime, GrandpaInstance, Msgs, Refund, Priority, Id>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RefundBridgedGrandpaMessages<Runtime, GrandpaInstance, Msgs, Refund, Priority, Id>, Error>
where __CodecInputEdqy: Input,

source§

impl<Runtime, Para, Msgs, Refund, Priority, Id> Decode for RefundBridgedParachainMessages<Runtime, Para, Msgs, Refund, Priority, Id>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RefundBridgedParachainMessages<Runtime, Para, Msgs, Refund, Priority, Id>, Error>
where __CodecInputEdqy: Input,

source§

impl<RuntimeCall> Decode for Instruction<RuntimeCall>

source§

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

source§

impl<RuntimeCall> Decode for Xcm<RuntimeCall>

source§

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

source§

impl<S> Decode for GenericSignedExtension<S>

source§

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

source§

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

source§

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

source§

impl<Size> Decode for ItemHeader<Size>
where Size: Decode,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for StorageEntryType<T>
where T: Form, <T as Form>::Type: Decode,

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for InitialPayment<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Event<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

impl<T> Decode for Event<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

impl<T> Decode for Event<T>
where T: Config, 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,

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

impl<T> Decode for Event<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for ConfigOp<T>
where T: Default + Codec + Decode,

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

impl<T> Decode for Event<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Event<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

impl<T> Decode for Event<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Event<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Error<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDef<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDef<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Call<T>
where T: Config,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for BinaryHeap<T>
where T: Decode + Ord,

source§

fn decode<I>(input: &mut I) -> Result<BinaryHeap<T>, Error>
where I: Input,

source§

impl<T> Decode for BTreeSet<T>
where T: Decode + Ord,

source§

fn decode<I>(input: &mut I) -> Result<BTreeSet<T>, Error>
where I: Input,

source§

impl<T> Decode for LinkedList<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<LinkedList<T>, Error>
where I: Input,

source§

impl<T> Decode for VecDeque<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<VecDeque<T>, Error>
where I: Input,

source§

impl<T> Decode for Vec<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<Vec<T>, Error>
where I: Input,

source§

impl<T> Decode for PhantomData<T>

source§

fn decode<I>(_input: &mut I) -> Result<PhantomData<T>, Error>
where I: Input,

source§

impl<T> Decode for Range<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<Range<T>, Error>
where I: Input,

source§

impl<T> Decode for RangeInclusive<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<RangeInclusive<T>, Error>
where I: Input,

source§

impl<T> Decode for StrippableError<T>
where PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<StrippableError<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for RefundSignedExtensionAdapter<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RefundSignedExtensionAdapter<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for ExtrinsicMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ExtrinsicMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PalletCallMetadata<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletCallMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

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,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletConstantMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PalletErrorMetadata<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletErrorMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PalletEventMetadata<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletEventMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PalletMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PalletStorageMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletStorageMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for SignedExtensionMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<SignedExtensionMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for StorageEntryMetadata<T>
where T: Form, <T as Form>::String: Decode, StorageEntryType<T>: Decode, Vec<<T as Form>::String>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<StorageEntryMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CustomMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CustomMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CustomValueMetadata<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CustomValueMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for ExtrinsicMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ExtrinsicMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for OuterEnums<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<OuterEnums<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PalletMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PalletMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for RuntimeApiMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RuntimeApiMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for RuntimeApiMethodMetadata<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RuntimeApiMethodMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for RuntimeApiMethodParamMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RuntimeApiMethodParamMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for SignedExtensionMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<SignedExtensionMetadata<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PerDispatchClass<T>
where T: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PerDispatchClass<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for WrapperKeepOpaque<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<WrapperKeepOpaque<T>, Error>
where I: Input,

source§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

source§

impl<T> Decode for WrapperOpaque<T>
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<WrapperOpaque<T>, Error>
where I: Input,

source§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

source§

impl<T> Decode for CheckGenesis<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckGenesis<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CheckMortality<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckMortality<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CheckNonZeroSender<T>
where PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckNonZeroSender<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CheckNonce<T>
where T: Config, <T as Config>::Nonce: HasCompact,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckNonce<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CheckSpecVersion<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckSpecVersion<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CheckTxVersion<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckTxVersion<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CheckWeight<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CheckWeight<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for CodeUpgradeAuthorization<T>
where T: Config, <T as Config>::Hash: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<CodeUpgradeAuthorization<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for ChargeAssetTxPayment<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ChargeAssetTxPayment<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Nominations<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Nominations<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for StakingLedger<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<StakingLedger<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for ChargeTransactionPayment<T>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ChargeTransactionPayment<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for PrevalidateAttests<T>
where PhantomData<fn(_: T)>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<PrevalidateAttests<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for UntrackedSymbol<T>
where PhantomData<fn() -> T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<UntrackedSymbol<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefComposite<T>
where T: Form, Vec<Field<T>>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefComposite<T>, Error>
where __CodecInputEdqy: Input,

source§

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,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Field<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Path<T>
where T: Form, Vec<<T as Form>::String>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Path<T>, Error>
where __CodecInputEdqy: Input,

source§

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,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Type<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefArray<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefArray<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefBitSequence<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefBitSequence<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefCompact<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefCompact<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefSequence<T>
where T: Form, <T as Form>::Type: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefSequence<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefTuple<T>
where T: Form, Vec<<T as Form>::Type>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefTuple<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeParameter<T>
where T: Form, <T as Form>::String: Decode, Option<<T as Form>::Type>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeParameter<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for TypeDefVariant<T>
where T: Form, Vec<Variant<T>>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefVariant<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Variant<T>
where T: Form, <T as Form>::String: Decode, Vec<Field<T>>: Decode, Vec<<T as Form>::String>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Variant<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T> Decode for Crossing<T>
where T: Encode + Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Crossing<T>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, E> Decode for Result<T, E>
where T: Decode, E: Decode,

source§

fn decode<I>(input: &mut I) -> Result<Result<T, E>, Error>
where I: Input,

source§

impl<T, H> Decode for Bounded<T, H>
where H: Hash, <H as Hash>::Output: Decode, PhantomData<T>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Bounded<T, H>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, Hash> Decode for MaybeHashed<T, Hash>
where T: Decode, Hash: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<MaybeHashed<T, Hash>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Error<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T, I>, Error>
where __CodecInputEdqy: Input,

source§

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,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Error<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T, I>, Error>
where __CodecInputEdqy: Input,

source§

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,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Error<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Event<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Error<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Event<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Error<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Event<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Error<T, I>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Error<T, I>, Error>
where __CodecInputEdqy: Input,

source§

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>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode, <<T as Config<I>>::Paymaster as Pay>::Id: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Event<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for Call<T, I>
where T: Config<I>, I: 'static,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Call<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for StoredAuthoritySet<T, I>
where T: Config<I>, I: 'static, BoundedVec<(Public, u64), StoredAuthorityListLimit<T, I>>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<StoredAuthoritySet<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, I> Decode for StoredInboundLaneData<T, I>
where T: Config<I>, I: 'static, InboundLaneData<<T as Config<I>>::InboundRelayer>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<StoredInboundLaneData<T, I>, Error>
where __CodecInputEdqy: Input,

source§

impl<T, S> Decode for BoundedBTreeSet<T, S>
where T: Decode + Ord, S: Get<u32>,

source§

fn decode<I>(input: &mut I) -> Result<BoundedBTreeSet<T, S>, Error>
where I: Input,

source§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

source§

impl<T, S> Decode for BoundedVec<T, S>
where T: Decode, S: Get<u32>,

source§

fn decode<I>(input: &mut I) -> Result<BoundedVec<T, S>, Error>
where I: Input,

source§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

source§

impl<T, S> Decode for WeakBoundedVec<T, S>
where T: Decode, S: Get<u32>,

source§

fn decode<I>(input: &mut I) -> Result<WeakBoundedVec<T, S>, Error>
where I: Input,

source§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

source§

impl<T, const N: usize> Decode for [T; N]
where T: Decode,

source§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where I: Input,

source§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<[T; N]> ) -> Result<DecodeFinished, Error>
where I: Input,

source§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

source§

fn encoded_fixed_size() -> Option<usize>

source§

impl<TBlockNumber> Decode for Commitment<TBlockNumber>
where TBlockNumber: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Commitment<TBlockNumber>, Error>
where __CodecInputEdqy: Input,

source§

impl<TBlockNumber, TSignature> Decode for SignedCommitment<TBlockNumber, TSignature>
where TBlockNumber: Decode + Clone, TSignature: Decode,

source§

fn decode<I>( input: &mut I ) -> Result<SignedCommitment<TBlockNumber, TSignature>, Error>
where I: Input,

source§

impl<TBlockNumber, TSignatureAccumulator> Decode for SignedCommitmentWitness<TBlockNumber, TSignatureAccumulator>
where Commitment<TBlockNumber>: Decode, TSignatureAccumulator: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<SignedCommitmentWitness<TBlockNumber, TSignatureAccumulator>, Error>
where __CodecInputEdqy: Input,

source§

impl<VoterIndex, TargetIndex, P> Decode for IndexAssignment<VoterIndex, TargetIndex, P>
where P: PerThing, VoterIndex: Decode, Vec<(TargetIndex, P)>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<IndexAssignment<VoterIndex, TargetIndex, P>, Error>
where __CodecInputEdqy: Input,

source§

impl<Xt> Decode for Block<Xt>
where Vec<Xt>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Block<Xt>, Error>
where __CodecInputEdqy: Input,

source§

impl<Xt> Decode for ExtrinsicWrapper<Xt>
where Xt: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ExtrinsicWrapper<Xt>, Error>
where __CodecInputEdqy: Input,

source§

impl<const LEFT_PLUS_RIGHT_LEN: usize> Decode for Public<LEFT_PLUS_RIGHT_LEN>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Public<LEFT_PLUS_RIGHT_LEN>, Error>
where __CodecInputEdqy: Input,

source§

impl<const LEFT_PLUS_RIGHT_LEN: usize> Decode for Signature<LEFT_PLUS_RIGHT_LEN>

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Signature<LEFT_PLUS_RIGHT_LEN>, Error>
where __CodecInputEdqy: Input,

Implementors§

source§

impl Decode for emulated_integration_tests_common::macros::WeightLimit

source§

impl Decode for emulated_integration_tests_common::impls::AggregateMessageOrigin

source§

impl Decode for emulated_integration_tests_common::impls::Junction

source§

impl Decode for emulated_integration_tests_common::impls::Junctions

source§

impl Decode for emulated_integration_tests_common::impls::NetworkId

source§

impl Decode for emulated_integration_tests_common::impls::Outcome

source§

impl Decode for UmpQueueId

source§

impl Decode for emulated_integration_tests_common::impls::XcmError

source§

impl Decode for emulated_integration_tests_common::impls::v3::AssetId

source§

impl Decode for emulated_integration_tests_common::impls::v3::AssetInstance

source§

impl Decode for emulated_integration_tests_common::impls::v3::BodyId

source§

impl Decode for emulated_integration_tests_common::impls::v3::BodyPart

source§

impl Decode for emulated_integration_tests_common::impls::v3::Fungibility

source§

impl Decode for emulated_integration_tests_common::impls::v3::Junction

source§

impl Decode for emulated_integration_tests_common::impls::v3::Junctions

source§

impl Decode for MaybeErrorCode

source§

impl Decode for emulated_integration_tests_common::impls::v3::MultiAssetFilter

source§

impl Decode for emulated_integration_tests_common::impls::v3::NetworkId

source§

impl Decode for OriginKind

source§

impl Decode for emulated_integration_tests_common::impls::v3::Outcome

source§

impl Decode for emulated_integration_tests_common::impls::v3::Response

source§

impl Decode for emulated_integration_tests_common::impls::v3::SendError

source§

impl Decode for emulated_integration_tests_common::impls::v3::WildFungibility

source§

impl Decode for emulated_integration_tests_common::impls::v3::WildMultiAsset

source§

impl Decode for HrmpChannel

source§

impl Decode for HrmpOpenChannelRequest

source§

impl Decode for OptionBool

source§

impl Decode for parity_scale_codec::compact::Compact<u8>

source§

impl Decode for parity_scale_codec::compact::Compact<u16>

source§

impl Decode for parity_scale_codec::compact::Compact<u32>

source§

impl Decode for parity_scale_codec::compact::Compact<u64>

source§

impl Decode for parity_scale_codec::compact::Compact<u128>

source§

impl Decode for parity_scale_codec::compact::Compact<()>

source§

impl Decode for AccountId32

source§

impl Decode for HrmpChannelId

source§

impl Decode for Location

source§

impl Decode for Id

source§

impl Decode for emulated_integration_tests_common::impls::v3::MultiAsset

source§

impl Decode for emulated_integration_tests_common::impls::v3::MultiAssets

source§

impl Decode for emulated_integration_tests_common::impls::v3::MultiLocation

source§

impl Decode for emulated_integration_tests_common::impls::v3::PalletInfo

source§

impl Decode for emulated_integration_tests_common::impls::v3::QueryResponseInfo

source§

impl Decode for Weight

source§

impl Decode for emulated_integration_tests_common::impls::v3::XcmContext

source§

impl<Call> Decode for emulated_integration_tests_common::impls::v3::Instruction<Call>

source§

impl<Call> Decode for emulated_integration_tests_common::impls::v3::Xcm<Call>

source§

impl<RuntimeCall> Decode for VersionedXcm<RuntimeCall>

source§

impl<T> Decode for emulated_integration_tests_common::impls::dmp::Call<T>
where T: Config,

source§

impl<T> Decode for emulated_integration_tests_common::impls::hrmp::Call<T>
where T: Config,

source§

impl<T> Decode for emulated_integration_tests_common::impls::hrmp::Error<T>

source§

impl<T> Decode for emulated_integration_tests_common::impls::hrmp::Event<T>
where T: Config,

source§

impl<T> Decode for parity_scale_codec::compact::Compact<T>
where T: CompactAs, Compact<<T as CompactAs>::As>: Decode,

source§

impl<T> Decode for DoubleEncoded<T>

source§

impl<T, X> Decode for X
where T: Decode + Into<X>, X: WrapperTypeDecode<Wrapped = T>,