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.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl Decode for ArithmeticError

source§

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

source§

impl Decode for DeriveJunction

source§

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

source§

impl Decode for LogLevel

source§

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

source§

impl Decode for LogLevelFilter

source§

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

source§

impl Decode for Void

source§

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

source§

impl Decode for HttpError

source§

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

source§

impl Decode for HttpRequestStatus

source§

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

source§

impl Decode for StorageKind

source§

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

source§

impl Decode for EcdsaVerifyError

source§

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

source§

impl Decode for MultiSignature

source§

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

source§

impl Decode for MultiSigner

source§

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

source§

impl Decode for TokenError

source§

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

source§

impl Decode for TransactionalError

source§

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

source§

impl Decode for DigestItem

source§

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

source§

impl Decode for Era

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for RuntimeString

source§

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

source§

impl Decode for DisableStrategy

source§

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

source§

impl Decode for ChildInfo

source§

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

source§

impl Decode for StateVersion

source§

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

source§

impl Decode for WasmLevel

source§

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

source§

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

source§

impl Decode for ReturnValue

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

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

source§

fn decode<R>(i: &mut R) -> Result<RingVerifierData, 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 Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for VrfPreOutput

source§

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 AccountId32

source§

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

source§

impl Decode for CryptoTypeId

source§

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

source§

impl Decode for KeyTypeId

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for HttpRequestId

source§

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

source§

impl Decode for OpaqueMultiaddr

source§

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

source§

impl Decode for OpaqueNetworkState

source§

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

source§

impl Decode for Timestamp

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for VrfPreOutput

source§

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 Digest

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for Time

source§

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

source§

impl Decode for AnySignature

source§

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

source§

impl Decode for Justifications

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for OpaqueExtrinsic

source§

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

source§

impl Decode for TestSignature

source§

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

source§

impl Decode for UintAuthorityId

source§

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

source§

impl Decode for BadOrigin

source§

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

source§

impl Decode for LookupError

source§

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

source§

impl Decode for ChildTrieParentKeyId

source§

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

source§

impl Decode for ChildTrieParentKeyId

source§

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

source§

impl Decode for StorageData

source§

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

source§

impl Decode for StorageData

source§

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

source§

impl Decode for StorageKey

source§

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

source§

impl Decode for StorageKey

source§

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

source§

impl Decode for TrackedStorageKey

source§

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

source§

impl Decode for WasmEntryAttributes

source§

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

§

impl Decode for String

§

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

§

impl Decode for NonZeroI8

§

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

§

impl Decode for NonZeroI16

§

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

§

impl Decode for NonZeroI32

§

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

§

impl Decode for NonZeroI64

§

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

§

impl Decode for NonZeroI128

§

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

§

impl Decode for NonZeroU8

§

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

§

impl Decode for NonZeroU16

§

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

§

impl Decode for NonZeroU32

§

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

§

impl Decode for NonZeroU64

§

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

§

impl Decode for NonZeroU128

§

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

§

impl Decode for Duration

§

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

§

impl Decode for Bytes

§

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

§

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

§

impl Decode for H512

§

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

§

impl Decode for H768

§

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

§

impl Decode for OpaqueMetadata

§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<OpaqueMetadata, 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 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 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 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 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<'a, T> Decode for Cow<'a, T>where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode,

§

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

source§

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

source§

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

source§

impl<AccountId, Balance> Decode for 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<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra>where Address: Decode, Signature: Decode, Call: Decode, Extra: SignedExtension,

source§

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

§

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 BlockAndTimeDeadline<B>where B: BlockNumberProvider, <B as BlockNumberProvider>::BlockNumber: Decode,

source§

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

source§

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<C> Decode for ArkScaleProjective<Projective<C>>where C: SWCurveConfig,

§

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

§

impl<C> Decode for ArkScaleProjective<Projective<C>>where C: TECurveConfig,

§

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

§

impl<C> Decode for PublicKey<C>where C: AffineRepr,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl<C> Decode for VrfPreOut<C>where C: AffineRepr,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

source§

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

source§

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

§

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,

§

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,

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,

§

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<Info> Decode for DispatchErrorWithPostInfo<Info>where Info: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable,

source§

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

§

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

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,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<P> Decode for VrfSignatureVec<P>where P: EcVrfProof,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl<P, const N: usize> Decode for VrfSignature<P, N>where P: EcVrfProof,

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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

§

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 Crossing<T>where T: Encode + Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Crossing<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 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 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 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 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 PalletCallMetadata<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for PalletMetadata<T>where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>>: Decode, Option<PalletErrorMetadata<T>>: Decode, 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,

§

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 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 RuntimeApiMetadata<T>where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodMetadata<T>>: Decode, Vec<<T as Form>::String>: Decode,

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

impl<T> Decode for 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 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, 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, const L: usize> Decode for ArkScaleLen<T, L>where T: CanonicalDeserialize,

§

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

§

impl<T, const L: usize> Decode for ArkScaleLen<T, L>where T: CanonicalDeserialize,

§

fn decode<I>(input: &mut I) -> Result<ArkScaleLen<T, L>, 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<T, const U: u8> Decode for ArkScale<T, U>where T: CanonicalDeserialize,

§

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

§

impl<T, const U: u8> Decode for ArkScale<T, U>where T: CanonicalDeserialize,

§

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

source§

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

source§

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

source§

impl<Xt> Decode for ExtrinsicWrapper<Xt>where Xt: Decode,

source§

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

source§

impl<const D: u32> Decode for RingContext<D>

source§

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

source§

impl<const LEFT_PLUS_RIGHT_LEN: usize> Decode for Public<LEFT_PLUS_RIGHT_LEN>

source§

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

source§

impl<const LEFT_PLUS_RIGHT_LEN: usize> Decode for Signature<LEFT_PLUS_RIGHT_LEN>

source§

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

Implementors§

source§

impl Decode for DispatchClass

source§

impl Decode for Pays

source§

impl Decode for Never

source§

impl Decode for VersionedPostUpgradeData

source§

impl Decode for frame_support::storage::child::ChildInfo

source§

impl Decode for KillStorageResult

source§

impl Decode for frame_support::storage::child::StateVersion

source§

impl Decode for ProcessMessageError

source§

impl Decode for Select

source§

impl Decode for UpgradeCheckSelect

source§

impl Decode for frame_support::traits::schedule::LookupError

source§

impl Decode for BalanceStatus

source§

impl Decode for PaymentStatus

source§

impl Decode for frame_support::pallet_prelude::DispatchError

source§

impl Decode for InvalidTransaction

source§

impl Decode for TransactionSource

source§

impl Decode for TransactionValidityError

source§

impl Decode for UnknownTransaction

source§

impl Decode for DispatchInfo

source§

impl Decode for PostDispatchInfo

source§

impl Decode for CheckInherentsResult

source§

impl Decode for frame_support::storage::child::MultiRemovalResults

source§

impl Decode for PalletId

source§

impl Decode for CrateVersion

source§

impl Decode for StorageInfo

source§

impl Decode for StorageVersion

source§

impl Decode for frame_support::traits::TrackedStorageKey

source§

impl Decode for WithdrawReasons

source§

impl Decode for OldWeight

source§

impl Decode for RuntimeDbWeight

source§

impl Decode for InherentData

source§

impl Decode for ValidTransaction

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<A, F, R, D> Decode for FreezeConsideration<A, F, R, D>where F: MutateFreeze<A>, F::Balance: Decode, PhantomData<fn() -> (A, R, D)>: Decode,

source§

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

source§

impl<A, Fx, Rx, D> Decode for LoneFreezeConsideration<A, Fx, Rx, D>where PhantomData<fn() -> (A, Fx, Rx, D)>: Decode,

source§

impl<A, Fx, Rx, D> Decode for LoneHoldConsideration<A, Fx, Rx, D>where PhantomData<fn() -> (A, Fx, Rx, D)>: Decode,

source§

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

source§

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

source§

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

source§

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

§

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

source§

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

source§

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

source§

impl<T, Hash> Decode for MaybeHashed<T, Hash>where T: Decode, Hash: Decode,

§

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

§

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

§

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

§

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

source§

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

source§

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