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 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<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 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 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<T> Decode for PalletCallMetadata<T>where T: Form, <T as Form>::Type: Decode,

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeMetadataPrefixed

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<RuntimeMetadataPrefixed, 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> Decode for ExtrinsicMetadata<T>where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>, Global>: Decode,

source§

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

source§

impl Decode for RuntimeMetadataV14

source§

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

source§

impl Decode for RuntimeMetadata

source§

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

source§

impl<T> Decode for PalletConstantMetadata<T>where T: Form, <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<PalletConstantMetadata<T>, Error>where __CodecInputEdqy: Input,

source§

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

source§

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

source§

impl Decode for StorageHasher

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeMetadataDeprecated

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for PalletMetadata<T>where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>, Global>: Decode, Option<PalletErrorMetadata<T>>: Decode,

source§

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

source§

impl Decode for StorageEntryModifier

source§

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

source§

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

source§

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

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<StorageData, 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<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 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 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 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<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 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 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<Reporter, Offender> Decode for OffenceDetails<Reporter, Offender>where Offender: Decode, Vec<Reporter, Global>: Decode,

source§

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

source§

impl Decode for DisableStrategy

source§

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

source§

impl Decode for RuntimeVersion

Implementors§

source§

impl Decode for Never

source§

impl Decode for Void

source§

impl Decode for frame_support::pallet_prelude::DispatchError

source§

impl Decode for InvalidTransaction

source§

impl Decode for TransactionSource

source§

impl Decode for TransactionValidityError

source§

impl Decode for UnknownTransaction

source§

impl Decode for ChildInfo

source§

impl Decode for KillStorageResult

source§

impl Decode for StateVersion

source§

impl Decode for ProcessMessageError

source§

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

source§

impl Decode for BalanceStatus

source§

impl Decode for DispatchClass

source§

impl Decode for Pays

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

source§

impl Decode for InherentData

source§

impl Decode for ValidTransaction

source§

impl Decode for Weight

source§

impl Decode for MultiRemovalResults

source§

impl Decode for PalletId

source§

impl Decode for CrateVersion

source§

impl Decode for StorageInfo

source§

impl Decode for StorageVersion

source§

impl Decode for TrackedStorageKey

source§

impl Decode for WithdrawReasons

source§

impl Decode for OldWeight

source§

impl Decode for RuntimeDbWeight

source§

impl Decode for DispatchInfo

source§

impl Decode for PostDispatchInfo

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> Decode for PhantomData<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

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