referrerpolicy=no-referrer-when-downgrade

Trait Decode

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

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

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

Required Methods§

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

Attempt to deserialise the value from input.

Provided Methods§

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

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

The default implementation will just call Decode::decode.

§Safety

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

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

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

Attempt to skip the encoded value from input.

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

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Dyn Compatibility§

This trait is not dyn compatible.

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

Implementations on Foreign Types§

§

impl Decode for bool

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for f32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for f64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i8

§

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

§

impl Decode for i16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for i128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u8

§

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

§

impl Decode for u16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for u128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for ()

§

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

§

impl Decode for String

§

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

§

impl Decode for NonZero<i8>

§

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

§

impl Decode for NonZero<i16>

§

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

§

impl Decode for NonZero<i32>

§

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

§

impl Decode for NonZero<i64>

§

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

§

impl Decode for NonZero<i128>

§

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

§

impl Decode for NonZero<u8>

§

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

§

impl Decode for NonZero<u16>

§

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

§

impl Decode for NonZero<u32>

§

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

§

impl Decode for NonZero<u64>

§

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

§

impl Decode for NonZero<u128>

§

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

§

impl Decode for Duration

§

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

§

impl Decode for AccountId32

§

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

§

impl Decode for AnySignature

§

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

§

impl Decode for Bytes

§

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

§

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

§

impl Decode for CryptoTypeId

§

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

§

impl Decode for DeriveJunction

§

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

§

impl Decode for Digest

§

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

§

impl Decode for DigestItem

§

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

§

impl Decode for DispatchClass

§

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

§

impl Decode for DispatchError

§

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

§

impl Decode for DispatchInfo

§

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

§

impl Decode for Duration

§

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

§

impl Decode for EcdsaVerifyError

§

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

§

impl Decode for Era

§

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

§

impl Decode for Error

§

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

§

impl Decode for H128

§

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

§

impl Decode for H384

§

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

§

impl Decode for H768

§

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

§

impl Decode for HttpError

§

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

§

impl Decode for HttpRequestId

§

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

§

impl Decode for HttpRequestStatus

§

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

§

impl Decode for InherentError

§

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

§

impl Decode for Justifications

§

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

§

impl Decode for KillStorageResult

§

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

§

impl Decode for LogLevelFilter

§

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

§

impl Decode for MembershipProof

§

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

§

impl Decode for MockCallU64

§

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

§

impl Decode for ModuleError

§

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

§

impl Decode for ModuleError

§

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

§

impl Decode for MultiRemovalResults

§

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

§

impl Decode for MultiSignature

§

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

§

impl Decode for MultiSigner

§

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

§

impl Decode for Never

§

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

§

impl Decode for OffenceSeverity

§

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

§

impl Decode for OpaqueExtrinsic

§

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

§

impl Decode for OpaqueMetadata

§

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

§

impl Decode for OpaqueMultiaddr

§

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

§

impl Decode for OpaqueNetworkState

§

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

§

impl Decode for OpaquePeerId

§

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

§

impl Decode for OpaqueValue

§

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

§

impl Decode for Pays

§

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

§

impl Decode for PortableRegistry

§

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

§

impl Decode for PortableType

§

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

§

impl Decode for PostDispatchInfo

§

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

§

impl Decode for Public

§

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

§

impl Decode for Public

§

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

§

impl Decode for Public

§

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

§

impl Decode for Public

§

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

§

impl Decode for Public

§

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

§

impl Decode for Public

§

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

§

impl Decode for ReturnValue

§

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

§

impl Decode for RingVerifierKey

§

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

§

impl Decode for RingVrfSignature

§

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

§

impl Decode for RuntimeMetadata

§

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

§

impl Decode for RuntimeMetadataDeprecated

§

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

§

impl Decode for RuntimeMetadataPrefixed

§

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

§

impl Decode for RuntimeMetadataV14

§

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

§

impl Decode for RuntimeMetadataV15

§

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

§

impl Decode for RuntimeMetadataV16

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Signature

§

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

§

impl Decode for Signature

§

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

§

impl Decode for SteppedMigrationError

§

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

§

impl Decode for StorageData

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl Decode for StorageHasher

§

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

§

impl Decode for StorageKey

§

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

§

impl Decode for StorageProofError

§

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

§

impl Decode for TestSignature

§

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

§

impl Decode for Time

§

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

§

impl Decode for Timestamp

§

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

§

impl Decode for Timestamp

§

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

§

impl Decode for TokenError

§

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

§

impl Decode for TransactionSource

§

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

§

impl Decode for TransactionValidityError

§

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

§

impl Decode for TransactionalError

§

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

§

impl Decode for TypeDefPrimitive

§

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

§

impl Decode for U128

§

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

§

impl Decode for UintAuthorityId

§

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

§

impl Decode for UnknownTransaction

§

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

§

impl Decode for Value

§

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

§

impl Decode for VersionedPostUpgradeData

§

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

§

impl Decode for ViewFunctionDispatchError

§

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

§

impl Decode for ViewFunctionId

§

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

§

impl Decode for Void

§

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

§

impl Decode for VrfPreOutput

§

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

§

impl Decode for VrfPreOutput

§

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

§

impl Decode for VrfProof

§

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

§

impl Decode for VrfSignature

§

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

§

impl Decode for VrfSignature

§

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

§

impl Decode for WasmEntryAttributes

§

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

§

impl Decode for WasmFieldName

§

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

§

impl Decode for WasmFields

§

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

§

impl Decode for WasmLevel

§

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

§

impl Decode for WasmMetadata

§

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

§

impl Decode for WasmValue

§

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

§

impl Decode for WasmValuesSet

§

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

§

impl<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<AccountId, AccountIndex> Decode for MultiAddress<AccountId, AccountIndex>
where AccountId: Decode, AccountIndex: HasCompact,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<B> Decode for BlockAndTimeDeadline<B>

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<H, L> Decode for MerkleProof<H, L>
where H: Decode, Vec<H>: Decode, L: Decode,

§

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

§

impl<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<Header, Extrinsic> Decode for Block<Header, Extrinsic>
where Header: Decode, Vec<Extrinsic>: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for 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 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 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 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 PalletViewFunctionMetadataIR<T>
where T: Form, <T as Form>::String: Decode, Vec<PalletViewFunctionParamMetadataIR<T>>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String>: Decode, ItemDeprecationInfoIR<T>: Decode,

§

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

§

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

§

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

§

impl<T> Decode for Path<T>
where T: Form, Vec<<T as Form>::String>: Decode,

§

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

§

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

§

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

§

impl<T> Decode for 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 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, D> Decode for TypeWithDefault<T, D>
where D: Get<T>, T: Decode, PhantomData<D>: Decode,

§

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

§

impl<T, E> Decode for Result<T, E>
where T: Decode, E: Decode,

§

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

§

impl<T, H> Decode for Bounded<T, H>
where H: Hash, <H as Hash>::Output: Decode, PhantomData<T>: Decode,

§

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

§

impl<T, S> Decode for BoundedBTreeSet<T, S>
where T: Decode + Ord, S: Get<u32>,

§

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

§

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

§

impl<T, S> Decode for WeakBoundedVec<T, S>
where T: Decode, S: Get<u32>,

§

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

§

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

§

impl<T, const N: usize> Decode for [T; N]
where T: Decode,

§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where I: Input,

§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<[T; N]>, ) -> Result<DecodeFinished, Error>
where I: Input,

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl<Xt> Decode for Block<Xt>
where Vec<Xt>: Decode,

§

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

§

impl<const N: usize> Decode for MigrationId<N>

§

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

§

impl<const N: usize, T> Decode for CryptoBytes<N, T>
where PhantomData<fn() -> T>: Decode,

§

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

§

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

§

impl<const R: usize> Decode for RingContext<R>

§

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

Implementors§

§

impl Decode for ArithmeticError

§

impl Decode for BenchmarkParameter

§

impl Decode for Phase

§

impl Decode for SignatureResult

§

impl Decode for ExtrinsicInclusionMode

§

impl Decode for polkadot_sdk_frame::runtime::testing_prelude::DispatchError

§

impl Decode for StateVersion

§

impl Decode for BalanceStatus

§

impl Decode for ProcessMessageError

§

impl Decode for TrieError

§

impl Decode for Select

§

impl Decode for UpgradeCheckSelect

§

impl Decode for Judgement

§

impl Decode for Statement

§

impl Decode for Truth

§

impl Decode for Social

§

impl Decode for polkadot_sdk_frame::traits::schedule::LookupError

§

impl Decode for PaymentStatus

§

impl Decode for InvalidTransaction

§

impl Decode for BigUint

§

impl Decode for FixedI64

§

impl Decode for FixedI128

§

impl Decode for FixedU64

§

impl Decode for FixedU128

§

impl Decode for PerU16

§

impl Decode for Perbill

§

impl Decode for Percent

§

impl Decode for Permill

§

impl Decode for Perquintill

§

impl Decode for BenchmarkBatch

§

impl Decode for BenchmarkBatchSplitResults

§

impl Decode for BenchmarkConfig

§

impl Decode for BenchmarkList

§

impl Decode for BenchmarkMetadata

§

impl Decode for BenchmarkResult

§

impl Decode for H160

§

impl Decode for H256

§

impl Decode for H512

§

impl Decode for U256

§

impl Decode for U512

§

impl Decode for BlockLength

§

impl Decode for BlockWeights

§

impl Decode for WeightsPerClass

§

impl Decode for DispatchEventInfo

§

impl Decode for LastRuntimeUpgradeInfo

§

impl Decode for PalletId

§

impl Decode for KeyTypeId

§

impl Decode for Slot

§

impl Decode for SlotDuration

§

impl Decode for StorageProof

§

impl Decode for CheckInherentsResult

§

impl Decode for InherentData

§

impl Decode for polkadot_sdk_frame::runtime::prelude::OpaqueMetadata

§

impl Decode for RuntimeVersion

§

impl Decode for RuntimeDbWeight

§

impl Decode for BadOrigin

§

impl Decode for ContextualAlias

§

impl Decode for CrateVersion

§

impl Decode for Disabled

§

impl Decode for polkadot_sdk_frame::traits::LookupError

§

impl Decode for SixteenPatriciaMerkleTreeExistenceProof

§

impl Decode for StorageInfo

§

impl Decode for StorageVersion

§

impl Decode for TrackedStorageKey

§

impl Decode for WithdrawReasons

§

impl Decode for ValidTransaction

§

impl Decode for Weight

§

impl Decode for Compact<u8>

§

impl Decode for Compact<u16>

§

impl Decode for Compact<u32>

§

impl Decode for Compact<u64>

§

impl Decode for Compact<u128>

§

impl Decode for Compact<()>

§

impl Decode for OptionBool

§

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

§

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,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for polkadot_sdk_frame::prelude::frame_system::Error<T>

§

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

§

impl<T> Decode for AuthorizeCall<T>
where PhantomData<T>: Decode,

§

impl<T> Decode for CheckGenesis<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

§

impl<T> Decode for CheckMortality<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

§

impl<T> Decode for CheckNonZeroSender<T>
where PhantomData<T>: Decode,

§

impl<T> Decode for CheckNonce<T>
where T: Config, <T as Config>::Nonce: HasCompact,

§

impl<T> Decode for CheckSpecVersion<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

§

impl<T> Decode for CheckTxVersion<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

§

impl<T> Decode for CheckWeight<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

§

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

§

impl<T> Decode for WeightReclaim<T>
where T: Config + Send + Sync, PhantomData<T>: Decode,

§

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

§

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

§

impl<T> Decode for PhantomData<T>

§

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

§

impl<T, Hash> Decode for MaybeHashed<T, Hash>
where T: Decode, Hash: 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>,

§

impl<WitnessData> Decode for Witness<WitnessData>
where PhantomData<WitnessData>: Decode,