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

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

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

Required Methods§

source

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

Attempt to deserialise the value from input.

Provided Methods§

source

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

Attempt to skip the encoded value from input.

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

source

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Implementations on Foreign Types§

source§

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

source§

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

source§

impl<T> Decode for VecDeque<T, Global>where T: Decode,

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroI32

source§

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

source§

impl<T> Decode for BTreeSet<T, Global>where T: Decode + Ord,

source§

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

source§

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

source§

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

source§

impl Decode for i8

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroU128

source§

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

source§

impl<T> Decode for PhantomData<T>

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroU16

source§

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

source§

impl<T> Decode for BinaryHeap<T, Global>where T: Decode + Ord,

source§

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

source§

impl Decode for NonZeroU32

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for Bytes

source§

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

source§

impl Decode for NonZeroI128

source§

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

source§

impl Decode for String

source§

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

source§

impl<T> Decode for LinkedList<T, Global>where T: Decode,

source§

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

source§

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

source§

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

source§

impl Decode for ()

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroU64

source§

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

source§

impl Decode for i32

source§

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

source§

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

source§

impl Decode for u128

source§

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

source§

impl Decode for u64

source§

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

source§

impl Decode for u8

source§

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

source§

impl Decode for i64

source§

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

source§

impl Decode for NonZeroI8

source§

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

source§

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

source§

impl Decode for i128

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for u16

source§

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

source§

impl Decode for f64

source§

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

source§

impl Decode for bool

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Vec<T, Global>where T: Decode,

source§

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

source§

impl Decode for Duration

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for f32

source§

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

source§

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

source§

impl Decode for u32

source§

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

source§

impl Decode for NonZeroI64

source§

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

source§

impl Decode for NonZeroU8

source§

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

source§

impl Decode for i16

source§

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

source§

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

source§

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

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Block<Xt>, 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<Header, Extrinsic> Decode for Block<Header, Extrinsic>where Extrinsic: MaybeSerialize, Header: Decode, Vec<Extrinsic, Global>: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Block<Header, Extrinsic>, 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<Info> Decode for DispatchErrorWithPostInfo<Info>where Info: Eq + PartialEq<Info> + Clone + Copy + Encode + Decode + Printable,

source§

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

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 Decode for TokenError

source§

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

source§

impl Decode for UnknownTransaction

source§

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

source§

impl Decode for TransactionSource

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TransactionSource, 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<Number, Hash> Decode for Header<Number, Hash>where Number: Copy + Into<U256> + TryFrom<U256> + HasCompact, Hash: Hash, <Hash as Hash>::Output: Decode,

source§

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

source§

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

source§

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

source§

impl Decode for BadOrigin

source§

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

source§

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

source§

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

source§

impl Decode for TransactionValidityError

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for DispatchError

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for ValidTransaction

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeString

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for Type<T>where T: Form, Path<T>: Decode, Vec<TypeParameter<T>, Global>: Decode, TypeDef<T>: Decode, Vec<<T as Form>::String, Global>: Decode,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for TypeDefPrimitive

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for PortableRegistry

source§

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

source§

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

source§

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

source§

impl Decode for Permill

source§

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

source§

impl Decode for PerU16

source§

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

source§

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

source§

impl Decode for Perbill

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for Timestamp

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for LocalizedSignature

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for Public

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for HttpRequestStatus

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for H384

source§

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

source§

impl Decode for U512

source§

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

source§

impl Decode for H128

source§

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

source§

impl Decode for U256

source§

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

source§

impl Decode for H256

source§

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

source§

impl Decode for H512

source§

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

source§

impl Decode for H160

source§

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

source§

impl Decode for H768

source§

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

source§

impl Decode for U128

source§

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

source§

impl Decode for KillStorageResult

source§

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

source§

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

source§

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

source§

impl Decode for EcdsaVerifyError

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeDbWeight

source§

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

source§

impl Decode for OldWeight

source§

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

source§

impl Decode for Weight

source§

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

Implementors§

source§

impl Decode for OptionBool

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<T> Decode for Compact<T>where T: CompactAs, Compact<<T as CompactAs>::As>: Decode,

source§

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

source§

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

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

impl<T> Decode for Error<T>

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

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

impl<T> Decode for Error<T>

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

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

impl Decode for Origin

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

impl<T> Decode for Error<T>

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

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

impl<H, N> Decode for Message<H, N>where Prevote<H, N>: Decode, Precommit<H, N>: Decode, PrimaryPropose<H, N>: 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 SignedPrevote<H, N, S, Id>where Prevote<H, N>: Decode, S: Decode, Id: 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 SignedMessage<H, N, S, Id>where Message<H, N>: Decode, S: Decode, Id: Decode,

impl<H, N> Decode for State<H, N>where Option<(H, N)>: Decode,

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

impl<H, N> Decode for Prevote<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 SignedPrecommit<H, N, S, Id>where Precommit<H, N>: Decode, S: Decode, Id: Decode,

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

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

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

impl<VoterIndex, TargetIndex, P: PerThing> Decode for IndexAssignment<VoterIndex, TargetIndex, P>where VoterIndex: Decode, Vec<(TargetIndex, P)>: 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 SignedExtensionMetadata<T>where T::String: Decode, T::Type: Decode,

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

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

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

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

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

impl Decode for Pays

impl Decode for PalletId

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

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

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

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

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

impl Decode for Never

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

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

impl<E, T> Decode for EventRecord<E, T>where E: Decode + Parameter + Member, Vec<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 + Send + Sync> Decode for CheckTxVersion<T>where PhantomData<T>: Decode,

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

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

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

impl<T> Decode for Error<T>

impl Decode for Phase

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

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

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

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

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

impl Decode for ListError

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where T::AccountId: Decode, T::Score: Decode,

impl<T, I> Decode for Error<T, I>

impl<T: Config<I>, I: 'static> Decode for Node<T, I>where T::AccountId: Decode, Option<T::AccountId>: Decode, T::Score: Decode, PhantomData<I>: Default,

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<T: Config<I>, I: 'static> Decode for Bag<T, I>where Option<T::AccountId>: Decode, T::Score: Default, PhantomData<I>: Default,

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

impl Decode for Reasons

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where T::AccountId: Decode, T::Balance: Decode,

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<T, I> Decode for Error<T, I>

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

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

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

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

impl<AccountId, BlockNumber> Decode for BountyStatus<AccountId, BlockNumber>where AccountId: Decode, BlockNumber: Decode,

impl<AccountId, Balance, BlockNumber> Decode for Bounty<AccountId, Balance, BlockNumber>where AccountId: Decode, Balance: Decode, BountyStatus<AccountId, BlockNumber>: Decode,

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where BalanceOf<T, I>: Decode, T::AccountId: Decode,

impl<T, I> Decode for Error<T, I>

impl<T> Decode for Error<T>

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

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

impl<T> Decode for Error<T>

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

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

impl<AccountId, Balance, BlockNumber> Decode for ChildBounty<AccountId, Balance, BlockNumber>where Balance: Decode, ChildBountyStatus<AccountId, BlockNumber>: Decode,

impl<AccountId, BlockNumber> Decode for ChildBountyStatus<AccountId, BlockNumber>where AccountId: Decode, BlockNumber: Decode,

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

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

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

impl<T> Decode for Error<T>

impl<AccountId, BlockNumber> Decode for Votes<AccountId, BlockNumber>where Vec<AccountId>: Decode, BlockNumber: Decode,

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

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

impl<T, I> Decode for Error<T, I>

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

impl<Balance, AccountId, BlockNumber, PollIndex, MaxVotes> Decode for Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>where MaxVotes: Get<u32>, Casting<Balance, BlockNumber, PollIndex, MaxVotes>: Decode, Delegating<Balance, AccountId, BlockNumber>: Decode,

impl<Balance, BlockNumber, PollIndex, MaxVotes> Decode for Casting<Balance, BlockNumber, PollIndex, MaxVotes>where MaxVotes: Get<u32>, BoundedVec<(PollIndex, AccountVote<Balance>), MaxVotes>: Decode, Delegations<Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode,

impl Decode for Vote

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

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

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

impl<Balance, AccountId, BlockNumber> Decode for Delegating<Balance, AccountId, BlockNumber>where Balance: Decode, AccountId: Decode, Delegations<Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode,

impl<Votes, Total> Decode for Tally<Votes, Total>where Votes: Decode + Clone + PartialEq + Eq + Debug + TypeInfo + Codec, PhantomData<Total>: Decode,

impl<T, I> Decode for Error<T, I>

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where T::AccountId: Decode,

impl<BlockNumber, Proposal, Balance> Decode for ReferendumInfo<BlockNumber, Proposal, Balance>where ReferendumStatus<BlockNumber, Proposal, Balance>: Decode, BlockNumber: Decode,

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

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

impl<Balance, AccountId, BlockNumber, MaxVotes: Get<u32>> Decode for Voting<Balance, AccountId, BlockNumber, MaxVotes>where BoundedVec<(ReferendumIndex, AccountVote<Balance>), MaxVotes>: Decode, Delegations<Balance>: Decode, PriorLock<BlockNumber, Balance>: Decode, Balance: Decode, AccountId: Decode,

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

impl<BlockNumber, Proposal, Balance> Decode for ReferendumStatus<BlockNumber, Proposal, Balance>where BlockNumber: Decode, Proposal: Decode, Tally<Balance>: Decode,

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

impl Decode for Vote

impl<T> Decode for Error<T>

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

impl<T: Config> Decode for RoundSnapshot<T>where Vec<VoterOf<T>>: Decode, Vec<T::AccountId>: Decode,

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

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

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

impl<T> Decode for Error<T>

impl<T> Decode for Error<T>

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

impl<AccountId, Balance> Decode for Voter<AccountId, Balance>where Vec<AccountId>: Decode, Balance: Decode,

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

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

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

impl<T> Decode for Error<T>

impl<T: Config> Decode for MaxChecking<T>where PhantomData<T>: Decode,

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

impl<T: Config> Decode for Event<T>where T::AccountId: Decode, BoundedVec<u8, T::MaxSize>: Decode,

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

impl<N, Limit> Decode for StoredPendingChange<N, Limit>where N: Decode, BoundedAuthorityList<Limit>: Decode, Option<N>: Decode,

impl Decode for Event

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

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

impl<Balance, AccountId> Decode for RegistrarInfo<Balance, AccountId>where AccountId: Decode + Encode + Decode + Clone + Debug + Eq + PartialEq, Balance: Decode + Encode + Decode + Clone + Debug + Eq + PartialEq,

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

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

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

impl<Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq, MaxJudgements: Get<u32>, MaxAdditionalFields: Get<u32>> Decode for Registration<Balance, MaxJudgements, MaxAdditionalFields>

impl Decode for Data

impl<T> Decode for Error<T>

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

impl<BlockNumber> Decode for Heartbeat<BlockNumber>where BlockNumber: PartialEq + Eq + Decode + Encode + Decode,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Decode for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>where PeerIdEncodingLimit: Get<u32>, MultiAddrEncodingLimit: Get<u32>, AddressesLimit: Get<u32>, WeakBoundedVec<u8, PeerIdEncodingLimit>: Decode, WeakBoundedVec<WeakBoundedVec<u8, MultiAddrEncodingLimit>, AddressesLimit>: Decode,

impl<T> Decode for Error<T>

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

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

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

impl<T> Decode for Error<T>

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

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

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

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

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where PhantomData<(T::AccountId, <T as Config<I>>::RuntimeEvent)>: Decode,

impl<T, I> Decode for Error<T, I>

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<BlockNumber, Balance, AccountId, MaxApprovals> Decode for Multisig<BlockNumber, Balance, AccountId, MaxApprovals>where MaxApprovals: Get<u32>, Timepoint<BlockNumber>: Decode, Balance: Decode, AccountId: Decode, BoundedVec<AccountId, MaxApprovals>: Decode,

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

impl<T> Decode for Error<T>

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

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

impl<AccountId, BlockNumber> Decode for ReceiptRecord<AccountId, BlockNumber>where AccountId: Decode, BlockNumber: Decode,

impl<T> Decode for Error<T>

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

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

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

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

impl Decode for PoolState

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

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

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

impl<T> Decode for ConfigOp<T>where T: Decode + Codec + Debug,

impl<B> Decode for OldRewardPool<B>where B: Decode,

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

impl<AccountId> Decode for PoolRoles<AccountId>where AccountId: Decode, Option<AccountId>: Decode,

impl<T> Decode for Error<T>

impl<T: Config> Decode for UnbondPool<T>where BalanceOf<T>: Decode,

impl Decode for Event

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

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

impl<T> Decode for Error<T>

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

impl<AccountId, Balance> Decode for RequestStatus<AccountId, Balance>where AccountId: Decode, Balance: Decode, (AccountId, Balance): Decode, Option<(AccountId, Balance)>: Decode,

impl<T: Config> Decode for Event<T>where T::AccountId: Decode, T::ProxyType: Decode, <<T as Config>::CallHasher as Hash>::Output: Decode, T::BlockNumber: Decode,

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

impl<T> Decode for Error<T>

impl<AccountId, Hash, BlockNumber> Decode for Announcement<AccountId, Hash, BlockNumber>where AccountId: Decode, Hash: Decode, BlockNumber: Decode,

impl<AccountId, ProxyType, BlockNumber> Decode for ProxyDefinition<AccountId, ProxyType, BlockNumber>where AccountId: Decode, ProxyType: Decode, BlockNumber: Decode,

impl<T, I> Decode for Error<T, I>

impl<T, I, M: GetMaxVoters> Decode for Tally<T, I, M>where PhantomData<(T, I, M)>: Decode,

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where T::AccountId: Decode, PollIndexOf<T, I>: Decode, TallyOf<T, I>: Decode,

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<BlockNumber, Balance, Friends> Decode for ActiveRecovery<BlockNumber, Balance, Friends>where BlockNumber: Decode, Balance: Decode, Friends: Decode,

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

impl<BlockNumber, Balance, Friends> Decode for RecoveryConfig<BlockNumber, Balance, Friends>where BlockNumber: Decode, Balance: Decode, Friends: Decode,

impl<T> Decode for Error<T>

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

impl<TrackId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, RuntimeOrigin: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Moment, Call: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone> Decode for ReferendumInfo<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>where ReferendumStatus<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>: Decode, Moment: Decode + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike, Deposit<AccountId, Balance>: Decode, Option<Deposit<AccountId, Balance>>: Decode,

impl<TrackId, RuntimeOrigin, Moment, Call, Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Tally, AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone> Decode for ReferendumStatus<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>where TrackId: Decode + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, RuntimeOrigin: Decode + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Call: Decode + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, DispatchTime<Moment>: Decode, Moment: Decode + Parameter + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike, Deposit<AccountId, Balance>: Decode, Option<Deposit<AccountId, Balance>>: Decode, Option<DecidingStatus<Moment>>: Decode, Tally: Decode + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Option<(Moment, ScheduleAddress)>: Decode,

impl<T, I> Decode for Error<T, I>

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where TrackIdOf<T, I>: Decode, BoundedCallOf<T, I>: Decode, T::AccountId: Decode, BalanceOf<T, I>: Decode, T::Tally: Decode,

impl<TrackId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, RuntimeOrigin: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Moment, Call: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone, ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone> Decode for ReferendumInfo<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>where ReferendumStatus<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>: Decode, Moment: Decode + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike, Option<Deposit<AccountId, Balance>>: Decode,

impl<BlockNumber> Decode for DecidingStatus<BlockNumber>where BlockNumber: Decode, Option<BlockNumber>: Decode,

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

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl Decode for Curve

impl<Name, Call, BlockNumber, PalletsOrigin, AccountId> Decode for Scheduled<Name, Call, BlockNumber, PalletsOrigin, AccountId>where Option<Name>: Decode, Call: Decode, Option<Period<BlockNumber>>: Decode, PalletsOrigin: Decode, PhantomData<AccountId>: Decode,

impl<T> Decode for Error<T>

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

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

impl Decode for Event

impl<T> Decode for Error<T>

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

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

impl<T> Decode for Error<T>

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

impl Decode for Vote

impl Decode for Judgement

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

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

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

impl<AccountId, Balance> Decode for Bid<AccountId, Balance>where AccountId: Decode, BidKind<AccountId, Balance>: Decode, Balance: Decode,

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

impl<T, I> Decode for Error<T, I>

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

impl<T> Decode for Error<T>

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

impl<T> Decode for ConfigOp<T>where T: Decode + Default + Codec,

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

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

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

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

impl Decode for Forcing

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

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

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

impl<T> Decode for Error<T>

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

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

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

impl<T, I> Decode for Error<T, I>

impl<AccountId, Balance, BlockNumber: Parameter, Hash> Decode for OpenTip<AccountId, Balance, BlockNumber, Hash>where Hash: Decode + Parameter, AccountId: Decode + Parameter, Balance: Decode + Parameter, Option<BlockNumber>: Decode, Vec<(AccountId, Balance)>: Decode,

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where T::Hash: Decode, T::AccountId: Decode, BalanceOf<T, I>: Decode,

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

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

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

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

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

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

impl<T: Config<I>, I: 'static> Decode for Event<T, I>where BalanceOf<T, I>: Decode, T::AccountId: Decode,

impl<T, I> Decode for Error<T, I>

impl<T> Decode for Error<T>

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

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

impl Decode for Event

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

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

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

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

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

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

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

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

impl Decode for Origin

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

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

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

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

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

impl Decode for View

impl Decode for PoV

impl Decode for Proof

impl Decode for Statement

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

impl Decode for BlockData

impl Decode for Id

impl Decode for HeadData

impl Decode for Sibling

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

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

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

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

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

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

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

impl Decode for CoreIndex

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

impl<H> Decode for CandidateEvent<H>where CandidateReceipt<H>: Decode,

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

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

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

impl<T> Decode for Error<T>

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

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

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

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

impl<T> Decode for Error<T>

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

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

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

impl<T: Config> Decode for Event<T>where <<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::LeasePeriod: Decode, T::BlockNumber: Decode, T::AccountId: Decode, <<<T as Config>::Leaser as Leaser<<T as Config>::BlockNumber>>::Currency as Currency<<T as Config>::AccountId>>::Balance: Decode,

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

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

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

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

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

impl<T> Decode for Error<T>

impl<T> Decode for Error<T>

impl Decode for SlotRange

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

impl<T> Decode for Error<T>

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

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

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

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

impl<T> Decode for Error<T>

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

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

impl<T> Decode for Error<T>

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

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

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

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

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

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

impl<T> Decode for Error<T>

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

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

impl Decode for Event

impl<T> Decode for Error<T>

impl<T> Decode for Error<T>

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

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

impl Decode for Event

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

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

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

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

impl Decode for ParaKind

impl<T> Decode for Error<T>

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

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

impl<T> Decode for Error<T>

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

impl Decode for Origin

impl<T> Decode for Error<T>

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

impl<T> Decode for Error<T>

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

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

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

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

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

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

impl Decode for Epoch

impl<E: Epoch> Decode for EpochHeader<E>where E::Slot: Decode,

impl<Hash, Number, E: Epoch> Decode for EpochChanges<Hash, Number, E>where ForkTree<Hash, Number, PersistedEpochHeader<E>>: Decode, BTreeMap<(Hash, Number), PersistedEpoch<E>>: Decode, Option<GapEpochs<Hash, Number, E>>: Decode,

impl<Hash, Number, E: Epoch> Decode for GapEpochs<Hash, Number, E>where Hash: Decode, Number: Decode, PersistedEpoch<E>: Decode, (Hash, Number, PersistedEpoch<E>): Decode, Option<(Hash, Number, E)>: Decode,

impl<Hash, Number, E: Epoch> Decode for EpochChangesV0<Hash, Number, E>where ForkTree<Hash, Number, PersistedEpoch<E>>: Decode,

impl<E> Decode for PersistedEpoch<E>where E: Decode,

impl<Hash, Number, E: Epoch> Decode for EpochChangesV1<Hash, Number, E>where ForkTree<Hash, Number, PersistedEpochHeader<E>>: Decode, BTreeMap<(Hash, Number), PersistedEpoch<E>>: Decode,

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

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

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

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

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

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

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

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

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

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

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

impl Decode for Direction

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

impl Decode for Roles

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

impl<TBlockNumber, TSignature> Decode for SignedCommitment<TBlockNumber, TSignature>where TBlockNumber: Decode + Clone, TSignature: Decode,

impl<TBlockNumber, TMerkleRoot> Decode for SignedCommitmentWitness<TBlockNumber, TMerkleRoot>where Commitment<TBlockNumber>: Decode, TMerkleRoot: Decode,

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

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

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

impl Decode for Public

impl<BlockNumber, Hash, MerkleRoot, ExtraData> Decode for MmrLeaf<BlockNumber, Hash, MerkleRoot, ExtraData>where BlockNumber: Decode, Hash: Decode, (BlockNumber, Hash): Decode, BeefyNextAuthoritySet<MerkleRoot>: Decode, ExtraData: Decode,

impl Decode for Payload

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

impl Decode for Signature

impl<TBlockNumber> Decode for Commitment<TBlockNumber>where TBlockNumber: Decode,

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

impl Decode for PreDigest

impl Decode for Epoch

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

impl Decode for Slot

impl Decode for VRFOutput

impl Decode for VRFProof

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

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

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

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

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

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

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

impl Decode for Error

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

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

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

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

impl Decode for Timestamp

impl Decode for Response

impl<RuntimeCall> Decode for Xcm<RuntimeCall>

impl Decode for Junction

impl<RuntimeCall> Decode for Order<RuntimeCall>

impl Decode for Outcome

impl Decode for SendError

impl Decode for Junction

impl<RuntimeCall> Decode for Xcm<RuntimeCall>

impl<T> Decode for DoubleEncoded<T>

impl Decode for Junctions

impl Decode for Outcome

impl Decode for Response

impl Decode for Response

impl Decode for BodyPart

impl Decode for Error

impl Decode for BodyId

impl<RuntimeCall> Decode for Instruction<RuntimeCall>

impl Decode for Outcome

impl Decode for NetworkId

impl<RuntimeCall> Decode for VersionedXcm<RuntimeCall>

impl Decode for Error

impl Decode for AssetId

impl<RuntimeCall> Decode for Order<RuntimeCall>

impl<RuntimeCall> Decode for Xcm<RuntimeCall>

impl Decode for Error