Trait parity_scale_codec::Decode

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

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

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

Required Methods§

source

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

Attempt to deserialise the value from input.

Provided Methods§

source

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

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

The default implementation will just call Decode::decode.

§Safety

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

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

source

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

Attempt to skip the encoded value from input.

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

source

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl Decode for bool

source§

impl Decode for f32

source§

impl Decode for f64

source§

impl Decode for i8

source§

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

source§

impl Decode for i16

source§

impl Decode for i32

source§

impl Decode for i64

source§

impl Decode for i128

source§

impl Decode for u8

source§

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

source§

impl Decode for u16

source§

impl Decode for u32

source§

impl Decode for u64

source§

impl Decode for u128

source§

impl Decode for ()

source§

impl Decode for Bytes

source§

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

source§

impl Decode for String

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for NonZeroI8

source§

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

source§

impl Decode for NonZeroI16

source§

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

source§

impl Decode for NonZeroI32

source§

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

source§

impl Decode for NonZeroI64

source§

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

source§

impl Decode for NonZeroI128

source§

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

source§

impl Decode for NonZeroU8

source§

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

source§

impl Decode for NonZeroU16

source§

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

source§

impl Decode for NonZeroU32

source§

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

source§

impl Decode for NonZeroU64

source§

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

source§

impl Decode for NonZeroU128

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<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> Decode for (D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

source§

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

source§

impl<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> Decode for (E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

source§

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

source§

impl<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> Decode for (F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for PhantomData<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T: Decode + Ord> Decode for BinaryHeap<T>

source§

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

source§

impl<T: Decode + Ord> Decode for BTreeSet<T>

source§

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

source§

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

source§

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

source§

impl<T: Decode> Decode for LinkedList<T>

source§

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

source§

impl<T: Decode> Decode for VecDeque<T>

source§

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

source§

impl<T: Decode> Decode for Vec<T>

source§

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

source§

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

source§

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

source§

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

Implementors§

source§

impl Decode for Compact<u8>

source§

impl Decode for Compact<u16>

source§

impl Decode for Compact<u32>

source§

impl Decode for Compact<u64>

source§

impl Decode for Compact<u128>

source§

impl Decode for Compact<()>

source§

impl Decode for OptionBool

source§

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

source§

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

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

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

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

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

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

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

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

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

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

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

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,

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

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

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

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

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

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

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

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

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

impl<T: Form> Decode for PalletCallMetadata<T>
where T::Type: Decode,

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

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

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

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

impl<T: Form> Decode for CustomValueMetadata<T>
where T::Type: Decode,

impl<T: Form> Decode for OuterEnums<T>
where T::Type: Decode,

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

impl Decode for Pays

impl Decode for Never

impl Decode for Select

impl Decode for PalletId

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

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

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<AssetId> Decode for NativeOrWithId<AssetId>
where AssetId: Ord + Decode,

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

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

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

impl<T, H: Hash> Decode for Bounded<T, H>

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

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

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

impl Decode for Phase

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

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

impl<T> Decode for Error<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Decode for View

impl Decode for Statement

impl Decode for PoV

impl Decode for Proof

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

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

impl Decode for BlockData

impl Decode for HeadData

impl Decode for Id

impl Decode for Sibling

impl Decode for UMPSignal

impl Decode for CoreIndex

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

impl<H> Decode for CandidateEvent<H>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Candidate, Digest> Decode for Statement<Candidate, Digest>
where Candidate: Decode, Digest: Decode,

impl<Candidate, Digest, AuthorityId, Signature> Decode for SignedStatement<Candidate, Digest, AuthorityId, Signature>
where Statement<Candidate, Digest>: Decode, Signature: Decode, AuthorityId: Decode,

impl<Group, Candidate, AuthorityId, Signature> Decode for AttestedCandidate<Group, Candidate, AuthorityId, Signature>
where Group: Decode, Candidate: Decode, Vec<(AuthorityId, ValidityAttestation<Signature>)>: Decode,

impl<Signature> Decode for ValidityAttestation<Signature>
where Signature: Decode,

impl Decode for H128

impl Decode for H160

impl Decode for H256

impl Decode for H384

impl Decode for H512

impl Decode for H768

impl Decode for U128

impl Decode for U256

impl Decode for U512

impl Decode for RemoteErr

impl Decode for Direction

impl Decode for Roles

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

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

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

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

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

impl<B: BlockT> Decode for WarpProofRequest<B>
where B::Hash: Decode,

impl<T> Decode for UntrackedSymbol<T>
where PhantomData<fn() -> T>: Decode,

impl<T: Form> Decode for Field<T>
where Option<T::String>: Decode, T::Type: Decode, Vec<T::String>: Decode,

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

impl<T: Form> Decode for Type<T>

impl<T: Form> Decode for TypeDefArray<T>
where T::Type: Decode,

impl<T: Form> Decode for TypeDefBitSequence<T>
where T::Type: Decode,

impl<T: Form> Decode for TypeDefCompact<T>
where T::Type: Decode,

impl<T: Form> Decode for TypeDefComposite<T>
where Vec<Field<T>>: Decode,

impl<T: Form> Decode for TypeDefSequence<T>
where T::Type: Decode,

impl<T: Form> Decode for TypeDefTuple<T>
where Vec<T::Type>: Decode,

impl<T: Form> Decode for TypeDefVariant<T>
where Vec<Variant<T>>: Decode,

impl<T: Form> Decode for TypeParameter<T>
where T::String: Decode, Option<T::Type>: Decode,

impl<T: Form> Decode for Variant<T>
where T::String: Decode, Vec<Field<T>>: Decode, Vec<T::String>: Decode,

impl Decode for Public

impl Decode for Signature

impl Decode for Public

impl Decode for Signature

impl Decode for Public

impl Decode for Signature

impl Decode for BigUint

impl Decode for FixedI128

impl Decode for FixedI64

impl Decode for FixedU128

impl Decode for FixedU64

impl Decode for PerU16

impl Decode for Perbill

impl Decode for Percent

impl Decode for Permill

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

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

impl Decode for PreDigest

impl Decode for Epoch

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

impl<Header: HeaderT> Decode for GrandpaJustification<Header>
where Commit<Header>: Decode, Vec<Header>: Decode,

impl<N> Decode for ConsensusLog<N>

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

impl Decode for Slot

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

impl Decode for LogLevel

impl Decode for Void

impl Decode for HttpError

impl Decode for KeyTypeId

impl Decode for Duration

impl Decode for Timestamp

impl Decode for VrfProof

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

impl<T> Decode for Crossing<T>
where T: Decode + Encode + Decode,

impl Decode for Mixnode

impl Decode for Era

impl Decode for TrieError

impl Decode for Digest

impl Decode for Time

impl Decode for BadOrigin

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

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

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

impl<Block: BlockT> Decode for BlockId<Block>
where Block::Hash: Decode, NumberFor<Block>: Decode,

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

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

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

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

impl<T, D: Get<T>> Decode for TypeWithDefault<T, D>
where T: Decode, PhantomData<D>: Decode,

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

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

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

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

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

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

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

impl Decode for Field

impl Decode for Proof

impl Decode for Statement

impl Decode for ChildInfo

impl Decode for Timestamp

impl Decode for WasmLevel

impl Decode for WasmValue

impl Decode for Error

impl Decode for Value

impl Decode for Weight

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

impl Decode for AssetId

impl Decode for BodyId

impl Decode for BodyPart

impl Decode for Error

impl Decode for Junction

impl Decode for Junctions

impl Decode for NetworkId

impl Decode for Outcome

impl Decode for Response

impl Decode for SendError

impl Decode for AssetId

impl Decode for BodyId

impl Decode for BodyPart

impl Decode for Error

impl Decode for Junction

impl Decode for Junctions

impl Decode for NetworkId

impl Decode for Outcome

impl Decode for Response

impl Decode for SendError

impl Decode for Junction

impl Decode for Junctions

impl Decode for NetworkId

impl Decode for Outcome

impl Decode for Response

impl Decode for WildAsset

impl Decode for Asset

impl Decode for AssetId

impl Decode for Assets

impl Decode for Location

impl<Call> Decode for Instruction<Call>

impl<Call> Decode for Instruction<Call>

impl<Call> Decode for Xcm<Call>

impl<Call> Decode for Xcm<Call>

impl<Call> Decode for Xcm<Call>

impl<RuntimeCall> Decode for VersionedXcm<RuntimeCall>

impl<RuntimeCall> Decode for Instruction<RuntimeCall>

impl<T> Decode for DoubleEncoded<T>