referrerpolicy=no-referrer-when-downgrade

Decode

Trait Decode 

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

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

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

Required Methods§

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

Attempt to deserialise the value from input.

Provided Methods§

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

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

The default implementation will just call Decode::decode.

§Safety

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

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

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

Attempt to skip the encoded value from input.

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

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Dyn Compatibility§

This trait is not dyn compatible.

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

Implementations on Foreign Types§

Source§

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

Source§

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

Source§

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

Source§

impl Decode for BridgeLocationsError

Source§

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

Source§

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

Source§

impl Decode for InboundHrmpMessageId

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for Statement

Source§

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

Source§

impl Decode for Truth

Source§

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

Source§

impl Decode for Social

Source§

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

Source§

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

Source§

impl Decode for Select

Source§

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

Source§

impl Decode for UpgradeCheckSelect

Source§

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

Source§

impl Decode for ViewFunctionDispatchError

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for ReceptionConfirmationError

Source§

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

Source§

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

Source§

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

Source§

impl Decode for TransactionSigned

Source§

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

Source§

impl Decode for Cursor

Source§

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

Source§

impl Decode for FreezeReason

Source§

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

Source§

impl Decode for HoldReason

Source§

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

Source§

impl Decode for BalanceConversionError

Source§

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

Source§

impl Decode for ContractAccessError

Source§

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

Source§

impl Decode for EthTransactError

Source§

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

Source§

impl Decode for BytecodeType

Source§

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

Source§

impl Decode for AccountIdVersionedInputPayload

Source§

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

Source§

impl Decode for AddressVersionedOutputPayload

Source§

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

Source§

impl Decode for BalanceVersionedInputPayload

Source§

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

Source§

impl Decode for BalanceVersionedOutputPayload

Source§

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

Source§

impl Decode for BlockAuthorVersionedInputPayload

Source§

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

Source§

impl Decode for BlockAuthorVersionedOutputPayload

Source§

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

Source§

impl Decode for BlockGasLimitVersionedInputPayload

Source§

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

Source§

impl Decode for BlockGasLimitVersionedOutputPayload

Source§

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

Source§

impl Decode for BlockHashVersionedInputPayload

Source§

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

Source§

impl Decode for BlockHashVersionedOutputPayload

Source§

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

Source§

impl Decode for CodeVersionedInputPayload

Source§

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

Source§

impl Decode for CodeVersionedOutputPayload

Source§

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

Source§

impl Decode for BlockVersionedInputPayload

Source§

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

Source§

impl Decode for BlockVersionedOutputPayload

Source§

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

Source§

impl Decode for EstimateGasVersionedOutputPayload

Source§

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

Source§

impl Decode for PreDispatchWeightVersionedInputPayload

Source§

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

Source§

impl Decode for PreDispatchWeightVersionedOutputPayload

Source§

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

Source§

impl Decode for GasPriceVersionedInputPayload

Source§

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

Source§

impl Decode for GasPriceVersionedOutputPayload

Source§

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

Source§

impl Decode for GetStorageVersionedInputPayload

Source§

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

Source§

impl Decode for GetStorageVersionedOutputPayload

Source§

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

Source§

impl Decode for MaxExtrinsicWeightInGasVersionedInputPayload

Source§

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

Source§

impl Decode for MaxExtrinsicWeightInGasVersionedOutputPayload

Source§

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

Source§

impl Decode for NewBalanceWithDustVersionedInputPayload

Source§

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

Source§

impl Decode for NonceVersionedInputPayload

Source§

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

Source§

impl Decode for ReceiptDataVersionedInputPayload

Source§

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

Source§

impl Decode for ReceiptDataVersionedOutputPayload

Source§

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

Source§

impl Decode for RuntimePalletsAddressVersionedInputPayload

Source§

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

Source§

impl Decode for RuntimePalletsAddressVersionedOutputPayload

Source§

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

Source§

impl Decode for TraceBlockVersionedOutputPayload

Source§

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

Source§

impl Decode for TraceCallVersionedInputPayload

Source§

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

Source§

impl Decode for TraceCallVersionedOutputPayload

Source§

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

Source§

impl Decode for TraceTxVersionedOutputPayload

Source§

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

Source§

impl Decode for CodeV1

Source§

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

Source§

impl Decode for StorageOverrideV1

Source§

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

Source§

impl Decode for StorageKeyV1

Source§

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

Source§

impl Decode for TracerTypeV1

Source§

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

Source§

impl Decode for CallTypeV1

Source§

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

Source§

impl Decode for ExecutionStepKindV1

Source§

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

Source§

impl Decode for PolkavmSyscallV1

Source§

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

Source§

impl Decode for PrestateTraceV1

Source§

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

Source§

impl Decode for TraceEntryV1

Source§

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

Source§

impl Decode for TraceV1

Source§

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

Source§

impl Decode for TraceV2

Source§

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

Source§

impl Decode for HashesOrTransactionInfosV1

Source§

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

Source§

impl Decode for TransactionSignedV1

Source§

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

Source§

impl Decode for HoldReason

Source§

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

Source§

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

Source§

impl Decode for Releases

Source§

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

Source§

impl Decode for ExecutionError

Source§

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

Source§

impl Decode for HoldReason

Source§

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

Source§

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

Source§

impl Decode for ValidationParamsExtension

Source§

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

Source§

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

Source§

impl Decode for CommittedCandidateReceiptError

Source§

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

Source§

impl Decode for CompactStatement

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for FailureReason

Source§

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

Source§

impl Decode for MessageToPara

Source§

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

Source§

impl Decode for MessageToParaV1

Source§

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

Source§

impl Decode for MigratedParaState

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for StorageProofError

Source§

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

Source§

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

Source§

impl Decode for VersionedAsset

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

impl Decode for bool

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for f32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for f64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i8

§

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

§

impl Decode for i16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u8

§

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

§

impl Decode for u16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for ()

§

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

Source§

impl Decode for AuthoritySet

Source§

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

Source§

impl Decode for HashedLaneId

Source§

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

Source§

impl Decode for LegacyLaneId

Source§

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

Source§

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

Source§

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

Source§

impl Decode for InboundMessageId

Source§

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

Source§

impl Decode for InboundMessagesData

Source§

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

Source§

impl Decode for MessagingStateSnapshot

Source§

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

Source§

impl Decode for RelayDispatchQueueRemainingCapacity

Source§

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

Source§

impl Decode for PoVMessages

Source§

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

Source§

impl Decode for RelayChainState

Source§

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

Source§

impl Decode for UsedBandwidth

Source§

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

Source§

impl Decode for SchedulingInfoPayload

Source§

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

Source§

impl Decode for SchedulingProof

Source§

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

Source§

impl Decode for SignedSchedulingInfo

Source§

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

Source§

impl Decode for BlockBundleInfo

Source§

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

Source§

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

Source§

impl Decode for RelayProofRequest

Source§

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

Source§

impl Decode for HashedMessage

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for BenchmarkBatchSplitResults

Source§

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

Source§

impl Decode for BenchmarkConfig

Source§

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

Source§

impl Decode for BenchmarkList

Source§

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

Source§

impl Decode for BenchmarkMetadata

Source§

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

Source§

impl Decode for BenchmarkResult

Source§

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

Source§

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

Source§

impl Decode for ContextualAlias

Source§

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

Source§

impl Decode for Disabled

Source§

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

Source§

impl Decode for Footprint

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for Block

Source§

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

Source§

impl Decode for Withdrawal

Source§

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

Source§

impl Decode for AccessListEntry

Source§

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

Source§

impl Decode for AuthorizationListEntry

Source§

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

Source§

impl Decode for Transaction1559Signed

Source§

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

Source§

impl Decode for Transaction1559Unsigned

Source§

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

Source§

impl Decode for Transaction2930Signed

Source§

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

Source§

impl Decode for Transaction2930Unsigned

Source§

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

Source§

impl Decode for Transaction4844Signed

Source§

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

Source§

impl Decode for Transaction4844Unsigned

Source§

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

Source§

impl Decode for Transaction7702Signed

Source§

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

Source§

impl Decode for Transaction7702Unsigned

Source§

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

Source§

impl Decode for TransactionInfo

Source§

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

Source§

impl Decode for TransactionLegacySigned

Source§

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

Source§

impl Decode for TransactionLegacyUnsigned

Source§

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

Source§

impl Decode for OutsideFrameLog

Source§

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

Source§

impl Decode for ReceiptGasInfo

Source§

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

Source§

impl Decode for SyntheticTransactionInfo

Source§

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

Source§

impl Decode for ExecError

Source§

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

Source§

impl Decode for Byte

Source§

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

Source§

impl Decode for Bytes8

Source§

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

Source§

impl Decode for Bytes32

Source§

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

Source§

impl Decode for Bytes256

Source§

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

Source§

impl Decode for Bytes

Source§

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

Source§

impl Decode for TypeEip1559

Source§

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

Source§

impl Decode for TypeEip2930

Source§

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

Source§

impl Decode for TypeEip4844

Source§

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

Source§

impl Decode for TypeEip7702

Source§

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

Source§

impl Decode for TypeLegacy

Source§

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

Source§

impl Decode for ReviveRuntimeApiVersionDeclarations

Source§

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

Source§

impl Decode for AccountIdInputPayloadV1

Source§

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

Source§

impl Decode for AddressOutputPayloadV1

Source§

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

Source§

impl Decode for BalanceInputPayloadV1

Source§

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

Source§

impl Decode for BalanceOutputPayloadV1

Source§

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

Source§

impl Decode for BlockAuthorInputPayloadV1

Source§

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

Source§

impl Decode for BlockAuthorOutputPayloadV1

Source§

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

Source§

impl Decode for BlockGasLimitInputPayloadV1

Source§

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

Source§

impl Decode for BlockGasLimitOutputPayloadV1

Source§

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

Source§

impl Decode for BlockHashInputPayloadV1

Source§

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

Source§

impl Decode for BlockHashOutputPayloadV1

Source§

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

Source§

impl Decode for CodeInputPayloadV1

Source§

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

Source§

impl Decode for CodeOutputPayloadV1

Source§

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

Source§

impl Decode for BlockInputPayloadV1

Source§

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

Source§

impl Decode for BlockOutputPayloadV1

Source§

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

Source§

impl Decode for EstimateGasOutputPayloadV1

Source§

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

Source§

impl Decode for PreDispatchWeightInputPayloadV1

Source§

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

Source§

impl Decode for PreDispatchWeightOutputPayloadV1

Source§

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

Source§

impl Decode for GasPriceInputPayloadV1

Source§

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

Source§

impl Decode for GasPriceOutputPayloadV1

Source§

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

Source§

impl Decode for GetStorageInputPayloadV1

Source§

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

Source§

impl Decode for GetStorageOutputPayloadV1

Source§

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

Source§

impl Decode for MaxExtrinsicWeightInGasInputPayloadV1

Source§

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

Source§

impl Decode for MaxExtrinsicWeightInGasOutputPayloadV1

Source§

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

Source§

impl Decode for NewBalanceWithDustInputPayloadV1

Source§

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

Source§

impl Decode for NonceInputPayloadV1

Source§

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

Source§

impl Decode for ReceiptDataInputPayloadV1

Source§

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

Source§

impl Decode for ReceiptDataInputPayloadV2

Source§

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

Source§

impl Decode for ReceiptDataOutputPayloadV1

Source§

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

Source§

impl Decode for ReceiptDataOutputPayloadV2

Source§

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

Source§

impl Decode for RuntimePalletsAddressInputPayloadV1

Source§

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

Source§

impl Decode for RuntimePalletsAddressOutputPayloadV1

Source§

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

Source§

impl Decode for TraceBlockOutputPayloadV1

Source§

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

Source§

impl Decode for TraceBlockOutputPayloadV2

Source§

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

Source§

impl Decode for TraceCallInputPayloadV1

Source§

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

Source§

impl Decode for TraceCallInputPayloadV2

Source§

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

Source§

impl Decode for TraceCallOutputPayloadV1

Source§

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

Source§

impl Decode for TraceCallOutputPayloadV2

Source§

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

Source§

impl Decode for TraceTxOutputPayloadV1

Source§

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

Source§

impl Decode for TraceTxOutputPayloadV2

Source§

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

Source§

impl Decode for BlockV1

Source§

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

Source§

impl Decode for WithdrawalV1

Source§

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

Source§

impl Decode for ExecReturnValueV1

Source§

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

Source§

impl Decode for InstantiateReturnValueV1

Source§

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

Source§

impl Decode for ReceiptGasInfoV1

Source§

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

Source§

impl Decode for SyntheticTransactionV1

Source§

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

Source§

impl Decode for StateOverrideSetV1

Source§

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

Source§

impl Decode for StateOverrideV1

Source§

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

Source§

impl Decode for TracingConfigV1

Source§

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

Source§

impl Decode for CallTracerConfigV1

Source§

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

Source§

impl Decode for ExecutionTracerConfigV1

Source§

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

Source§

impl Decode for PrestateTracerConfigV1

Source§

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

Source§

impl Decode for CallLogV1

Source§

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

Source§

impl Decode for CallLogV2

Source§

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

Source§

impl Decode for CallTraceV1

Source§

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

Source§

impl Decode for CallTraceV2

Source§

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

Source§

impl Decode for EvmOpcodeV1

Source§

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

Source§

impl Decode for ExecutionStepV1

Source§

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

Source§

impl Decode for ExecutionTraceV1

Source§

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

Source§

impl Decode for PrestateTraceInfoV1

Source§

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

Source§

impl Decode for AccessListEntryV1

Source§

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

Source§

impl Decode for AuthorizationListEntryV1

Source§

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

Source§

impl Decode for GenericTransactionV1

Source§

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

Source§

impl Decode for InputOrDataV1

Source§

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

Source§

impl Decode for Transaction1559SignedV1

Source§

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

Source§

impl Decode for Transaction1559UnsignedV1

Source§

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

Source§

impl Decode for Transaction2930SignedV1

Source§

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

Source§

impl Decode for Transaction2930UnsignedV1

Source§

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

Source§

impl Decode for Transaction4844SignedV1

Source§

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

Source§

impl Decode for Transaction4844UnsignedV1

Source§

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

Source§

impl Decode for Transaction7702SignedV1

Source§

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

Source§

impl Decode for Transaction7702UnsignedV1

Source§

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

Source§

impl Decode for TransactionInfoV1

Source§

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

Source§

impl Decode for TransactionLegacySignedV1

Source§

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

Source§

impl Decode for TransactionLegacyUnsignedV1

Source§

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

Source§

impl Decode for ReturnFlags

Source§

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

Source§

impl Decode for SlashingSpan

Source§

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

Source§

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

Source§

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

Source§

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

Manual Decode to enforce the canonical form: non-empty, strictly increasing ParaIds. An empty set has nothing the relay could match; a candidate that requires nothing emits no Requires signal.

Source§

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

Source§

impl Decode for StreamsRoot

Source§

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

Source§

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

Source§

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

Source§

impl Decode for ChunkIndex

Source§

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

Source§

impl Decode for ClaimQueueOffset

Source§

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

Source§

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

Source§

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

Source§

impl Decode for AssignmentState

Source§

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

Source§

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

Source§

impl Decode for BlockAttributes

Source§

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

Source§

impl Decode for ProofOfPossession

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Decode for RingVrfSignature

Source§

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

Source§

impl Decode for VrfPreOutput

Source§

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

Source§

impl Decode for VrfSignature

Source§

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

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

Source§

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

Source§

impl Decode for VrfProof

Source§

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

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 ModuleInvalidity

Source§

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

Source§

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

Source§

impl Decode for MockCallU64

Source§

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

Source§

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

Source§

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

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

Source§

impl Decode for RuntimeDbWeight

Source§

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

Source§

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

Source§

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

Source§

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

§

impl Decode for String

§

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

§

impl Decode for NonZero<i8>

§

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

§

impl Decode for NonZero<i16>

§

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

§

impl Decode for NonZero<i32>

§

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

§

impl Decode for NonZero<i64>

§

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

§

impl Decode for NonZero<i128>

§

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

§

impl Decode for NonZero<u8>

§

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

§

impl Decode for NonZero<u16>

§

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

§

impl Decode for NonZero<u32>

§

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

§

impl Decode for NonZero<u64>

§

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

§

impl Decode for NonZero<u128>

§

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

§

impl Decode for Duration

§

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

§

impl Decode for AccountId20

§

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

§

impl Decode for AccountId32

§

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

§

impl Decode for AccountValidity

§

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

§

impl Decode for Bits

§

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

§

impl Decode for BlockGapType

§

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

§

impl Decode for Bloom

§

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

§

impl Decode for Bytes

Available on crate feature bytes only.
§

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

§

impl Decode for ChannelSignal

§

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

§

impl Decode for ChildInfo

§

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

§

impl Decode for ChildTrieParentKeyId

§

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

§

impl Decode for DeriveJunction

§

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

§

impl Decode for Digest

§

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

§

impl Decode for DigestItem

§

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

§

impl Decode for EcdsaSignature

§

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

§

impl Decode for ElectionCompute

§

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

§

impl Decode for Era

§

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

§

impl Decode for ErrorMetadata

§

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

§

impl Decode for ErrorMetadata

§

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

§

impl Decode for ErrorMetadata

§

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

§

impl Decode for ErrorMetadata

§

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

§

impl Decode for ErrorMetadata

§

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

§

impl Decode for ErrorMetadata

§

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

§

impl Decode for EthereumAddress

§

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

§

impl Decode for EventMetadata

§

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

§

impl Decode for EventMetadata

§

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

§

impl Decode for EventMetadata

§

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

§

impl Decode for EventMetadata

§

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

§

impl Decode for EventMetadata

§

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

§

impl Decode for EventMetadata

§

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

§

impl Decode for ExtrinsicMetadata

§

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

§

impl Decode for ExtrinsicMetadata

§

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

§

impl Decode for ExtrinsicMetadata

§

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

§

impl Decode for ForeignAssetReserveData

§

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

§

impl Decode for FunctionArgumentMetadata

§

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

§

impl Decode for FunctionArgumentMetadata

§

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

§

impl Decode for FunctionArgumentMetadata

§

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

§

impl Decode for FunctionArgumentMetadata

§

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

§

impl Decode for FunctionArgumentMetadata

§

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

§

impl Decode for FunctionArgumentMetadata

§

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

§

impl Decode for FunctionMetadata

§

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

§

impl Decode for FunctionMetadata

§

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

§

impl Decode for FunctionMetadata

§

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

§

impl Decode for FunctionMetadata

§

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

§

impl Decode for FunctionMetadata

§

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

§

impl Decode for FunctionMetadata

§

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

§

impl Decode for FungiblesAccessError

§

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

§

impl Decode for H32

§

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

§

impl Decode for H64

§

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

§

impl Decode for H128

§

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

§

impl Decode for H160

§

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

§

impl Decode for H256

§

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

§

impl Decode for H264

§

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

§

impl Decode for H384

§

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

§

impl Decode for H512

§

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

§

impl Decode for H520

§

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

§

impl Decode for H768

§

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

§

impl Decode for InboundChannelDetails

§

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

§

impl Decode for InboundState

§

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

§

impl Decode for Metadata

§

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

§

impl Decode for ModuleConstantMetadata

§

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

§

impl Decode for ModuleConstantMetadata

§

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

§

impl Decode for ModuleConstantMetadata

§

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

§

impl Decode for ModuleConstantMetadata

§

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

§

impl Decode for ModuleConstantMetadata

§

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

§

impl Decode for ModuleConstantMetadata

§

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

§

impl Decode for ModuleMetadata

§

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

§

impl Decode for ModuleMetadata

§

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

§

impl Decode for ModuleMetadata

§

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

§

impl Decode for ModuleMetadata

§

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

§

impl Decode for ModuleMetadata

§

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

§

impl Decode for ModuleMetadata

§

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

§

impl Decode for MultiSignature

§

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

§

impl Decode for OpaqueMetadata

§

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

§

impl Decode for OutboundChannelDetails

§

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

§

impl Decode for OutboundState

§

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

§

impl Decode for OuterEventMetadata

§

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

§

impl Decode for OuterEventMetadata

§

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

§

impl Decode for OuterEventMetadata

§

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

§

impl Decode for OuterEventMetadata

§

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

§

impl Decode for OuterEventMetadata

§

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

§

impl Decode for OuterEventMetadata

§

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

§

impl Decode for Phase

§

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

§

impl Decode for PortableRegistry

§

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

§

impl Decode for PortableType

§

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

§

impl Decode for QueueConfigData

§

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

§

impl Decode for QueueConfigData

§

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

§

impl Decode for RuntimeMetadata

§

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

§

impl Decode for RuntimeMetadataDeprecated

Available on crate feature decode only.
§

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

§

impl Decode for RuntimeMetadataPrefixed

§

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

§

impl Decode for RuntimeMetadataV8

§

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

§

impl Decode for RuntimeMetadataV9

§

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

§

impl Decode for RuntimeMetadataV10

§

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

§

impl Decode for RuntimeMetadataV11

§

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

§

impl Decode for RuntimeMetadataV12

§

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

§

impl Decode for RuntimeMetadataV13

§

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

§

impl Decode for RuntimeMetadataV14

§

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

§

impl Decode for RuntimeMetadataV15

§

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

§

impl Decode for RuntimeMetadataV16

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Signature

§

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

§

impl Decode for SlotLeasePeriodStart

§

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

§

impl Decode for SlotRange

§

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

§

impl Decode for SolutionOrSnapshotSize

§

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

§

impl Decode for StateVersion

§

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

§

impl Decode for StatementKind

§

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

§

impl Decode for StorageData

§

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

§

impl Decode for StorageEntryMetadata

§

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

§

impl Decode for StorageEntryMetadata

§

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

§

impl Decode for StorageEntryMetadata

§

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

§

impl Decode for StorageEntryMetadata

§

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

§

impl Decode for StorageEntryMetadata

§

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

§

impl Decode for StorageEntryMetadata

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageEntryType

§

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

§

impl Decode for StorageEntryType

§

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

§

impl Decode for StorageEntryType

§

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

§

impl Decode for StorageEntryType

§

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

§

impl Decode for StorageEntryType

§

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

§

impl Decode for StorageEntryType

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageKey

§

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

§

impl Decode for StorageMetadata

§

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

§

impl Decode for StorageMetadata

§

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

§

impl Decode for StorageMetadata

§

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

§

impl Decode for StorageMetadata

§

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

§

impl Decode for StorageMetadata

§

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

§

impl Decode for StorageMetadata

§

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

§

impl Decode for TrackedStorageKey

§

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

§

impl Decode for TransactionInvalid

§

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

§

impl Decode for TransactionUnknown

§

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

§

impl Decode for TransactionValid

§

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

§

impl Decode for TypeDefPrimitive

§

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

§

impl Decode for U64

§

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

§

impl Decode for U128

§

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

§

impl Decode for U256

§

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

§

impl Decode for U512

§

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

§

impl Decode for VersionedLocatableAccount

§

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

§

impl Decode for VersionedLocatableAsset

§

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

§

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

§

impl<A> Decode for MigrationState<A>
where A: Decode,

§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<A, U, S> Decode for MigrationState<A, U, S>
where A: Decode, U: Decode, S: Decode,

Source§

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

§

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

§

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

§

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

§

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

Source§

impl<AccountId> Decode for AccountIdVersionedOutputPayload<AccountId>
where AccountIdOutputPayloadV1<AccountId>: Decode,

Source§

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

Source§

impl<AccountId> Decode for AddressVersionedInputPayload<AccountId>
where AddressInputPayloadV1<AccountId>: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<AccountId> Decode for Admin<AccountId>
where PhantomData<AccountId>: Decode,

Source§

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

Source§

impl<AccountId> Decode for Owner<AccountId>
where PhantomData<AccountId>: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

Source§

impl<AccountId, BOuter, BInner> Decode for BoundedSupports<AccountId, BOuter, BInner>
where BOuter: Get<u32>, BInner: Get<u32>, BoundedVec<(AccountId, BoundedSupport<AccountId, BInner>), BOuter>: Decode,

Source§

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

Source§

impl<AccountId, Balance> Decode for CallVersionedInputPayload<AccountId, Balance>
where CallInputPayloadV1<AccountId, Balance>: Decode,

Source§

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

Source§

impl<AccountId, Balance> Decode for InstantiateVersionedInputPayload<AccountId, Balance>
where InstantiateInputPayloadV1<AccountId, Balance>: Decode,

Source§

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

Source§

impl<AccountId, Balance> Decode for UploadCodeVersionedInputPayload<AccountId, Balance>
where UploadCodeInputPayloadV1<AccountId, Balance>: Decode,

Source§

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

Source§

impl<AccountId, Balance> Decode for RegionRecord<AccountId, Balance>
where Option<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 CallInputPayloadV1<AccountId, Balance>
where AccountId: Decode, Balance: Decode, Option<Balance>: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<UploadCodeInputPayloadV1<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, AssetKind, Hash, PaymentId, Beneficiary> Decode for Bounty<AccountId, Balance, AssetKind, Hash, PaymentId, Beneficiary>
where AssetKind: Decode, Balance: Decode, Hash: Decode, BountyStatus<AccountId, PaymentId, Beneficiary>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Bounty<AccountId, Balance, AssetKind, Hash, PaymentId, Beneficiary>, Error>
where __CodecInputEdqy: Input,

§

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

§

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

Source§

impl<AccountId, Balance, Hash, PaymentId, Beneficiary> Decode for ChildBounty<AccountId, Balance, Hash, PaymentId, Beneficiary>
where Balance: Decode, Hash: Decode, BountyStatus<AccountId, PaymentId, Beneficiary>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ChildBounty<AccountId, Balance, Hash, PaymentId, Beneficiary>, Error>
where __CodecInputEdqy: Input,

§

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

§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

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<AccountId, PaymentId, Beneficiary> Decode for BountyStatus<AccountId, PaymentId, Beneficiary>
where AccountId: Decode, PaymentState<PaymentId>: Decode, Option<AccountId>: Decode, Beneficiary: Decode,

Source§

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

§

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

§

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

Source§

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

Source§

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

§

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

§

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

Source§

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

Source§

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

Source§

impl<Address, Signature, ExtensionV0, ExtensionOtherVersions> Decode for Preamble<Address, Signature, ExtensionV0, ExtensionOtherVersions>
where Address: Decode, Signature: Decode, ExtensionV0: Decode, ExtensionOtherVersions: DecodeWithVersion,

Source§

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

§

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 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 BlockAndTimeDeadline<B>

Source§

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

§

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

§

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

§

impl<B, O> Decode for DecodeDifferent<B, O>
where B: 'static, O: Decode + 'static,

Available on crate feature std only.
§

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

Source§

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

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Imbalance<B, OnDrop, OppositeOnDrop>, 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 CallVersionedOutputPayload<Balance>
where CallOutputPayloadV1<Balance>: Decode,

Source§

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

Source§

impl<Balance> Decode for TransactVersionedOutputPayload<Balance>

Source§

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

Source§

impl<Balance> Decode for InstantiateVersionedOutputPayload<Balance>

Source§

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

Source§

impl<Balance> Decode for NewBalanceWithDustVersionedOutputPayload<Balance>

Source§

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

Source§

impl<Balance> Decode for UploadCodeVersionedOutputPayload<Balance>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<Balance> Decode for CallOutputPayloadV1<Balance>

Source§

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

Source§

impl<Balance> Decode for TransactOutputPayloadV1<Balance>
where EthTransactInfoV1<Balance>: Decode,

Source§

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

Source§

impl<Balance> Decode for InstantiateOutputPayloadV1<Balance>

Source§

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

Source§

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

Source§

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

Source§

impl<Balance> Decode for UploadCodeOutputPayloadV1<Balance>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AccountStatus<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, 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, RelayBlockNumber> Decode for SaleInfoRecord<Balance, RelayBlockNumber>
where RelayBlockNumber: Decode, Balance: Decode, Option<Balance>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SaleInfoRecord<Balance, RelayBlockNumber>, Error>
where __CodecInputEdqy: 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 ParachainBlockData<Block>
where Block: Decode,

Source§

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

Source§

impl<Block> Decode for TraceBlockVersionedInputPayload<Block>

Source§

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

Source§

impl<Block> Decode for TraceTxVersionedInputPayload<Block>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

§

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

§

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

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 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 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 V12HostConfiguration<BlockNumber>
where BlockNumber: Decode, SchedulerParams<BlockNumber>: Decode,

Source§

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

§

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

§

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

§

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

§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

Source§

impl<Call> Decode for Instruction<Call>
where Call: Decode,

Source§

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

Source§

impl<Call> Decode for Instruction<Call>
where Call: Decode,

Source§

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

Source§

impl<Call> Decode for Instruction<Call>
where Call: Decode,

Source§

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

Source§

impl<Call> Decode for Xcm<Call>
where Call: Decode,

Source§

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

Source§

impl<Call> Decode for Xcm<Call>
where Call: Decode,

Source§

fn decode<I>(input: &mut I) -> Result<Xcm<Call>, Error>
where I: 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<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Decode for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>, Error>
where __CodecInputEdqy: Input,

Source§

impl<ConfigValue, Extra> Decode for WithConfig<ConfigValue, Extra>
where ConfigValue: ConfigValueMarker + Decode, Extra: Decode,

Source§

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

§

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 ReceptionResult<DispatchLevelResult>
where MessageDispatchResult<DispatchLevelResult>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ReceptionResult<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<DispatchLevelResult, LaneId> Decode for ReceivedMessages<DispatchLevelResult, LaneId>
where LaneId: Decode, Vec<(u64, ReceptionResult<DispatchLevelResult>)>: Decode,

Source§

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

§

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

§

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

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<Event> Decode for CallDryRunEffects<Event>
where Vec<Event>: Decode,

Source§

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

Source§

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

Source§

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

§

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

§

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

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,

§

impl<G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)
where G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

§

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

§

impl<H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)
where H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

§

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

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 Ancestor<H>
where Option<H>: Decode,

Source§

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

Source§

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

Source§

impl<H> Decode for CandidateReceiptV2<H>

Source§

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

Source§

impl<H> Decode for CommittedCandidateReceiptV2<H>

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CommittedCandidateReceiptV2<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> Decode for IgnoredNodes<H>
where H: Decode + Hash + Eq,

Source§

fn decode<I>(input: &mut I) -> Result<IgnoredNodes<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, L> Decode for MerkleProof<H, L>
where H: Decode, Vec<H>: Decode, L: Decode,

Source§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

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 RelayParentInfo<Hash>
where Hash: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<Hash, BlockNumber> Decode for AllowedSchedulingParentsTracker<Hash, BlockNumber>
where VecDeque<SchedulingParentInfo<Hash>>: Decode, BlockNumber: Decode,

Source§

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

§

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

§

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

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, Extrinsic> Decode for LazyBlock<Header, Extrinsic>
where Header: Decode, PhantomData<Extrinsic>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<LazyBlock<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<Header, Id, AncestryProof> Decode for ForkVotingProof<Header, Id, AncestryProof>
where Header: Header + Decode, Id: RuntimeAppPublic, VoteMessage<<Header as Header>::Number, Id, <Id as RuntimeAppPublic>::Signature>: Decode, AncestryProof: Decode,

Source§

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

§

impl<I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)
where I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

§

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

Source§

impl<I> Decode for HoldReason<I>
where I: 'static,

Source§

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

Source§

impl<I> Decode for HoldReason<I>
where I: 'static,

Source§

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

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

§

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

§

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

Source§

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

Source§

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

Source§

impl<Inner> Decode for FakeDispatchable<Inner>
where Inner: Decode,

Source§

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

Source§

impl<Inspect> Decode for ConfigValue<Inspect>
where Inspect: InspectStrategy, <Inspect as InspectStrategy>::Value: Decode,

Source§

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

§

impl<J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (J0, K0, L0, M0, N0, O0, P0, Q0, R0)
where J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode,

§

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

§

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

§

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

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,

§

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

§

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

§

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

§

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

§

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

Source§

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

Source§

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

§

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

§

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

Source§

impl<LaneId> Decode for Message<LaneId>
where LaneId: Encode, MessageKey<LaneId>: Decode,

Source§

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

Source§

impl<LaneId> Decode for MessageKey<LaneId>
where LaneId: Encode + Decode,

Source§

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

§

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

§

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

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<Message> Decode for AbridgedInboundMessagesCollection<Message>
where Message: InboundMessage, Vec<Message>: Decode, Vec<<Message as InboundMessage>::CompressedMessage>: Decode,

Source§

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

Source§

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

Source§

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

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<Moment> Decode for EstimateGasVersionedInputPayload<Moment>

Source§

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

Source§

impl<Moment> Decode for TransactVersionedInputPayload<Moment>

Source§

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

Source§

impl<Moment> Decode for EstimateGasInputPayloadV1<Moment>
where Option<Moment>: Decode,

Source§

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

Source§

impl<Moment> Decode for TransactInputPayloadV1<Moment>
where Option<Moment>: Decode,

Source§

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

Source§

impl<Moment> Decode for DryRunConfigV1<Moment>
where Moment: Decode,

Source§

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

§

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

§

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

Source§

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

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 OrderQueue<N>
where BoundedVec<EnqueuedOrder<N>, ConstU32<polkadot_runtime_parachains::::on_demand::_#4::{impl#0}::{constant#0}>>: Decode, BoundedVec<EnqueuedOrder<N>, ConstU32<polkadot_runtime_parachains::::on_demand::_#4::{impl#0}::{constant#1}>>: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

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> Decode for NonceVersionedOutputPayload<Nonce>

Source§

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

Source§

impl<Nonce> Decode for NonceOutputPayloadV1<Nonce>
where Nonce: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<NonceOutputPayloadV1<Nonce>, 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> Decode for FutureBlockVotingProof<Number, Id>
where Id: RuntimeAppPublic, VoteMessage<Number, Id, <Id as RuntimeAppPublic>::Signature>: Decode,

Source§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

Source§

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

Source§

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

Source§

impl<Params, ReportedId> Decode for DeriveAndReportId<Params, ReportedId>
where Params: Decode, PhantomData<ReportedId>: Decode,

Source§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

Source§

impl<R, Balance> Decode for ContractResultV1<R, Balance>
where StorageDepositV1<Balance>: Decode, Balance: Decode, Result<R, DispatchError>: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

Source§

impl<SE> Decode for AsTransactionExtension<SE>
where SE: SignedExtension + Decode,

Source§

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

§

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

§

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

Source§

impl<T> Decode for BlockWeightMode<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<BlockWeightMode<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>::Hash: Decode, <T as Config>::AccountId: Decode, <T as Config>::RuntimeTask: 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>::Currency as Inspect<<T as Config>::AccountId>>::Balance: Decode,

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for Error<T>

Source§

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

Source§

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

Source§

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

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Origin<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 Event<T>
where T: Config, <T as Config>::ValidatorId: 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 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 Event<T>
where T: Config, <T as Config>::Hash: Decode, <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 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 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 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, <T as Config>::AccountId: Decode, Vec<(Id, <<<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 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 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 Call<T>
where T: Config,

Source§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

Source§

impl<T> Decode for 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 NoDrop<T>
where T: Default + Decode,

Source§

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

Source§

impl<T> Decode for AuthorizeCall<T>
where PhantomData<T>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AuthorizeCall<T>, Error>
where __CodecInputEdqy: 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 WeightReclaim<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for MaxChecking<T>
where T: Config, PhantomData<T>: Decode,

Source§

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

Source§

impl<T> Decode for UnstakeRequest<T>

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for AccountInfo<T>
where T: Config, AccountType<T>: Decode,

Source§

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

Source§

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

Source§

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

Source§

impl<T> Decode for ContractBlob<T>
where T: Config, CodeInfo<T>: Default,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ContractBlob<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>
where T: Config, <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::Balance: HasCompact,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for PhantomData<T>

§

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

§

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

§

fn decode<I>(input: &mut I) -> Result<Range<T>, Error>
where I: Input,

§

impl<T> Decode for RangeInclusive<T>
where T: Decode,

§

fn decode<I>(input: &mut I) -> Result<RangeInclusive<T>, Error>
where I: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Call<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Call<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for CustomMetadata<T>
where T: Form, BTreeMap<<T as Form>::String, CustomValueMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CustomMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for CustomValueMetadata<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CustomValueMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for EnumDeprecationInfo<T>
where T: Form, BTreeMap<u8, VariantDeprecationInfo<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<EnumDeprecationInfo<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Error<T>

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Error<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <<T as Config>::Leaser as Leaser<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::LeasePeriod: Decode, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode, <T as Config>::AccountId: Decode, <<<T as Config>::Leaser as Leaser<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<<T as Config>::Auctioneer as Auctioneer<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<<T as Config>::VestingSchedule as VestingSchedule<<T as Config>::AccountId>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, <T as Config>::AccountId: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config, Option<<T as Config>::AccountId>: Decode, <T as Config>::AccountId: Decode, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode, Phase<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Event<T>
where T: Config,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Event<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for ExtrinsicMetadata<T>
where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ExtrinsicMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for ExtrinsicMetadata<T>
where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ExtrinsicMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for ExtrinsicMetadata<T>
where T: Form, <T as Form>::Type: Decode, Vec<TransactionExtensionMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ExtrinsicMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Field<T>
where T: Form, Option<<T as Form>::String>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Field<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for ItemDeprecationInfo<T>
where T: Form, <T as Form>::String: Decode, Option<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ItemDeprecationInfo<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for OuterEnums<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<OuterEnums<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletAssociatedTypeMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletAssociatedTypeMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletCallMetadata<T>
where T: Form, <T as Form>::Type: Decode, EnumDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletCallMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletCallMetadata<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletCallMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletConstantMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletConstantMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletConstantMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletConstantMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletErrorMetadata<T>
where T: Form, <T as Form>::Type: Decode, EnumDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletErrorMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletErrorMetadata<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletErrorMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletEventMetadata<T>
where T: Form, <T as Form>::Type: Decode, EnumDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletEventMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletEventMetadata<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletEventMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletMetadata<T>
where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>>: Decode, Option<PalletErrorMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletMetadata<T>
where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>>: Decode, Option<PalletErrorMetadata<T>>: Decode, Vec<PalletAssociatedTypeMetadata<T>>: Decode, Vec<PalletViewFunctionMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletMetadata<T>
where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>>: Decode, Option<PalletErrorMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletStorageMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<StorageEntryMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletStorageMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletStorageMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<StorageEntryMetadata<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletStorageMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PalletViewFunctionMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodParamMetadata<T>>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PalletViewFunctionMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Path<T>
where T: Form, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Path<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for PrevalidateAttests<T>
where PhantomData<fn(T)>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PrevalidateAttests<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for RuntimeApiMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeApiMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for RuntimeApiMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeApiMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for RuntimeApiMethodMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodParamMetadata<T>>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeApiMethodMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for RuntimeApiMethodMetadata<T>
where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodParamMetadata<T>>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeApiMethodMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for RuntimeApiMethodParamMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<RuntimeApiMethodParamMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for SignedExtensionMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SignedExtensionMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for SignedExtensionMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<SignedExtensionMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Static<T>
where T: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Static<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for StorageEntryMetadata<T>
where T: Form, <T as Form>::String: Decode, StorageEntryType<T>: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfo<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StorageEntryMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for StorageEntryMetadata<T>
where T: Form, <T as Form>::String: Decode, StorageEntryType<T>: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StorageEntryMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for StorageEntryType<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StorageEntryType<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TransactionExtensionMetadata<T>
where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TransactionExtensionMetadata<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Type<T>
where T: Form, Path<T>: Decode, Vec<TypeParameter<T>>: Decode, TypeDef<T>: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Type<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDef<T>
where T: Form, TypeDefComposite<T>: Decode, TypeDefVariant<T>: Decode, TypeDefSequence<T>: Decode, TypeDefArray<T>: Decode, TypeDefTuple<T>: Decode, TypeDefCompact<T>: Decode, TypeDefBitSequence<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDef<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefArray<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefArray<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefBitSequence<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefBitSequence<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefCompact<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefCompact<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefComposite<T>
where T: Form, Vec<Field<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefComposite<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefSequence<T>
where T: Form, <T as Form>::Type: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefSequence<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefTuple<T>
where T: Form, Vec<<T as Form>::Type>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefTuple<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeDefVariant<T>
where T: Form, Vec<Variant<T>>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeDefVariant<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for TypeParameter<T>
where T: Form, <T as Form>::String: Decode, Option<<T as Form>::Type>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeParameter<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for UntrackedSymbol<T>
where PhantomData<fn() -> T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<UntrackedSymbol<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for Variant<T>
where T: Form, <T as Form>::String: Decode, Vec<Field<T>>: Decode, Vec<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Variant<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for VariantDeprecationInfo<T>
where T: Form, <T as Form>::String: Decode, Option<<T as Form>::String>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<VariantDeprecationInfo<T>, Error>
where __CodecInputEdqy: Input,

§

impl<T> Decode for WrapperKeepOpaque<T>
where PhantomDataSendSync<T>: Decode,

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<WrapperKeepOpaque<T>, Error>
where __CodecInputEdqy: Input,

Source§

impl<T, D> Decode for TypeWithDefault<T, D>
where D: Get<T>, T: Decode, PhantomData<D>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<TypeWithDefault<T, D>, Error>
where __CodecInputEdqy: Input,

§

impl<T, E> Decode for Result<T, E>
where T: Decode, E: Decode,

§

fn decode<I>(input: &mut I) -> Result<Result<T, E>, Error>
where I: Input,

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, Vec<<T as Config<I>>::ReserveData>: 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, <T as Config<I>>::RuntimeHoldReason: 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<I>>::LaneId: Decode, ReceivedMessages<<<T as Config<I>>::MessageDispatch as MessageDispatch>::DispatchLevelResult, <T as Config<I>>::LaneId>: 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 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>>::Beneficiary: Decode, <T as Config<I>>::AssetKind: Decode, <T as Config<I>>::Balance: Decode, <<T as Config<I>>::Paymaster as PayWithSource>::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 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<I>>::BlockNumberProvider as BlockNumberProvider>::BlockNumber: 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 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<<T as Config<I>>::BridgeMessagesPalletInstance>>::ThisChain as Chain>::Balance: Decode, <T as Config<<T as Config<I>>::BridgeMessagesPalletInstance>>::LaneId: 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 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 AssetDetailsViewFunction<T, I>
where T: Config<I>, I: 'static,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AssetDetailsViewFunction<T, I>, Error>
where __CodecInputEdqy: Input,

Source§

impl<T, I> Decode for BalanceOfViewFunction<T, I>
where T: Config<I>, I: 'static,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<BalanceOfViewFunction<T, I>, Error>
where __CodecInputEdqy: Input,

Source§

impl<T, I> Decode for GetMetadataViewFunction<T, I>
where T: Config<I>, I: 'static,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<GetMetadataViewFunction<T, I>, Error>
where __CodecInputEdqy: Input,

Source§

impl<T, I> Decode for GetReservesDataViewFunction<T, I>
where T: Config<I>, I: 'static,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<GetReservesDataViewFunction<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>>::BridgedChain as Chain>::AccountId>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StoredInboundLaneData<T, I>, Error>
where __CodecInputEdqy: Input,

§

impl<T, S> Decode for BoundedBTreeSet<T, S>
where T: Decode + Ord, S: Get<u32>,

§

fn decode<I>(input: &mut I) -> Result<BoundedBTreeSet<T, S>, Error>
where I: Input,

§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

§

impl<T, S> Decode for WeakBoundedVec<T, S>
where T: Decode, S: Get<u32>,

§

fn decode<I>(input: &mut I) -> Result<WeakBoundedVec<T, S>, Error>
where I: Input,

§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

§

impl<T, const N: usize> Decode for [T; N]
where T: Decode,

§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where I: Input,

§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<[T; N]>, ) -> Result<DecodeFinished, Error>
where I: Input,

§

fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

§

fn encoded_fixed_size() -> Option<usize>

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<ThisChain, LaneId> Decode for Bridge<ThisChain, LaneId>
where ThisChain: Chain, LaneId: LaneIdType + Decode, <ThisChain as Chain>::AccountId: Decode, <ThisChain as Chain>::Balance: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Bridge<ThisChain, LaneId>, Error>
where __CodecInputEdqy: Input,

Source§

impl<Ticket, MAX> Decode for AuthorizedAliasesEntry<Ticket, MAX>
where MAX: Get<u32>, BoundedVec<OriginAliaser, MAX>: Decode, Ticket: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<AuthorizedAliasesEntry<Ticket, MAX>, 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<WitnessData> Decode for Witness<WitnessData>
where PhantomData<WitnessData>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Witness<WitnessData>, 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<const N: usize> Decode for MigrationId<N>

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<MigrationId<N>, Error>
where __CodecInputEdqy: Input,

Source§

impl<const N: usize, T> Decode for CryptoBytes<N, T>
where PhantomData<fn() -> T>: Decode,

Source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CryptoBytes<N, T>, Error>
where __CodecInputEdqy: Input,

Source§

fn decode_into<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<CryptoBytes<N, T>>, ) -> Result<DecodeFinished, Error>
where __CodecInputEdqy: Input,

Source§

impl<const R: usize> Decode for RingContext<R>

Source§

fn decode<I>(input: &mut I) -> Result<RingContext<R>, Error>
where I: Input,

Implementors§

Source§

impl Decode for AssetTransferFilter

Source§

impl Decode for MaybeErrorCode

Source§

impl Decode for TransferType

Source§

impl Decode for VersionedAssetId

Source§

impl Decode for VersionedAssets

Source§

impl Decode for VersionedLocation

Source§

impl Decode for WeightLimit

Source§

impl Decode for emulated_integration_tests_common::macros::XcmPaymentApiError

Source§

impl Decode for MigrationCursor

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 OriginKind

Source§

impl Decode for emulated_integration_tests_common::impls::Outcome

Source§

impl Decode for UmpQueueId

Source§

impl Decode for XcmBridgeHubCall

Source§

impl Decode for emulated_integration_tests_common::impls::XcmError

Source§

impl Decode for DepositAction

Source§

impl Decode for DepositError

Source§

impl Decode for emulated_integration_tests_common::macros::AssetId

Source§

impl Decode for emulated_integration_tests_common::macros::Assets

Source§

impl Decode for emulated_integration_tests_common::macros::XcmContext

Source§

impl Decode for DepositChange

Source§

impl Decode for DepositChangeRequest

Source§

impl Decode for HrmpChannel

Source§

impl Decode for HrmpOpenChannelRequest

Source§

impl Decode for emulated_integration_tests_common::impls::AccountId32

Source§

impl Decode for emulated_integration_tests_common::impls::Asset

Source§

impl Decode for HrmpChannelId

Source§

impl Decode for emulated_integration_tests_common::impls::Location

Source§

impl Decode for Id

Source§

impl Decode for Weight

§

impl Decode for Compact<u8>

§

impl Decode for Compact<u16>

§

impl Decode for Compact<u32>

§

impl Decode for Compact<u64>

§

impl Decode for Compact<u128>

§

impl Decode for Compact<()>

§

impl Decode for OptionBool

Source§

impl<AccountId> Decode for RawOrigin<AccountId>
where AccountId: Decode,

Source§

impl<Call> Decode for emulated_integration_tests_common::macros::Xcm<Call>
where Call: Decode,

Source§

impl<RuntimeCall> Decode for VersionedXcm<RuntimeCall>
where RuntimeCall: Decode,

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::dmp::Event<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 DoubleEncoded<T>
where T: Decode,

§

impl<T> Decode for Compact<T>
where T: CompactAs, Compact<<T as CompactAs>::As>: Decode,

§

impl<T, S> Decode for BoundedVec<T, S>
where T: Decode, S: Get<u32>,

§

impl<T, X> Decode for X
where T: Decode + Into<X>, X: WrapperTypeDecode<Wrapped = T>,