Trait frame_support::pallet_prelude::Encode

pub trait Encode {
    // Provided methods
    fn size_hint(&self) -> usize { ... }
    fn encode_to<T>(&self, dest: &mut T)
       where T: Output + ?Sized { ... }
    fn encode(&self) -> Vec<u8>  { ... }
    fn using_encoded<R, F>(&self, f: F) -> R
       where F: FnOnce(&[u8]) -> R { ... }
    fn encoded_size(&self) -> usize { ... }
}

Trait that allows zero-copy write of value-references to slices in LE format.

Implementations should override using_encoded for value types and encode_to and size_hint for allocating types. Wrapper types should override all methods.

Provided Methods

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

This method is used inside default implementation of encode to avoid re-allocations.

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

Should be used when the encoded data isn’t required.

Note

This works by using a special [Output] that only tracks the size. So, there are no allocations inside the output. However, this can not prevent allocations that some types are doing inside their own encoding.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Encode for ArithmeticError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for DeriveJunction

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for LogLevel

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for LogLevelFilter

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Void

impl Encode for HttpError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for HttpRequestStatus

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StorageKind

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for EcdsaVerifyError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StorageEntryModifierIR

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StorageHasherIR

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for ExtrinsicInclusionMode

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for MultiSignature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for MultiSigner

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for TokenError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for TransactionalError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for DigestItem

fn encode(&self) -> Vec<u8>

impl Encode for Era

fn encode_to<T>(&self, output: &mut T)

where T: Output + ?Sized,

impl Encode for DispatchError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for ChildInfo

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StateVersion

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmLevel

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmLevel

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmValue

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmValue

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Error

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StorageProofError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for ReturnValue

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for ReturnValue

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Value

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Value

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for bool

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for f32

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for f64

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for i8

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for i16

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for i32

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for i64

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for i128

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for str

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for u8

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for u16

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for u32

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for u64

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for u128

fn size_hint(&self) -> usize

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for ()

fn encode_to<W>(&self, _dest: &mut W)

where W: Output + ?Sized,

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn encode(&self) -> Vec<u8>

impl Encode for Public

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Signature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Public

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Signature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Public

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Signature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Public

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Signature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Public

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Signature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Public

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Signature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for BigUint

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for FixedI64

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for FixedI128

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for FixedU64

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for FixedU128

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for PerU16

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Perbill

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Percent

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Permill

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Perquintill

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for RingVerifierData

fn encode(&self) -> Vec<u8>

impl Encode for RingVrfSignature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for VrfPreOutput

fn encode(&self) -> Vec<u8>

impl Encode for VrfSignature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for AccountId32

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for CryptoTypeId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for KeyTypeId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Duration

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for HttpRequestId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for OpaqueMultiaddr

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for OpaqueNetworkState

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Timestamp

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for VrfPreOutput

fn encode(&self) -> Vec<u8>

impl Encode for VrfProof

fn encode(&self) -> Vec<u8>

impl Encode for VrfSignature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for OpaqueMetadata

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for OpaquePeerId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for MultiRemovalResults

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Digest

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for ModuleError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for Time

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for AnySignature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for Justifications

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for ModuleError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for OpaqueExtrinsic

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for OpaqueValue

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for MockCallU64

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for TestSignature

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for UintAuthorityId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for BadOrigin

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for LookupError

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for OffenceSeverity

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for ChildTrieParentKeyId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for ChildTrieParentKeyId

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for StorageData

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for StorageData

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for StorageKey

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for StorageKey

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for TrackedStorageKey

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmEntryAttributes

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmEntryAttributes

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmFieldName

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for WasmFieldName

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for WasmFields

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for WasmFields

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for WasmMetadata

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmMetadata

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for WasmValuesSet

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for WasmValuesSet

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for CompactProof

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for StorageProof

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for RuntimeVersion

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for NonZero<i8>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<i16>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<i32>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<i64>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<i128>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<u8>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<u16>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<u32>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<u64>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for NonZero<u128>

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for Duration

fn size_hint(&self) -> usize

fn encode(&self) -> Vec<u8>

impl Encode for H128

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H128

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H160

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H160

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H256

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H256

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H384

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H384

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H512

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H512

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H768

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for H768

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for OpaqueMetadata

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for PortableRegistry

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl Encode for PortableType

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for RuntimeMetadata

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for RuntimeMetadataDeprecated

fn encode_to<W>(&self, _dest: &mut W)

where W: Output + ?Sized,

impl Encode for RuntimeMetadataPrefixed

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for RuntimeMetadataV14

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for RuntimeMetadataV15

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for RuntimeMetadataV16

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StorageEntryModifier

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for StorageHasher

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for TypeDefPrimitive

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl Encode for U128

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for U128

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for U256

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for U256

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for U512

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl Encode for U512

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl<'a> Encode for DigestItemRef<'a>

fn encode(&self) -> Vec<u8>

impl<'a, C> Encode for ArkScaleProjective<&'a Projective<C>>

where C: SWCurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<'a, C> Encode for ArkScaleProjective<&'a Projective<C>>

where C: SWCurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<'a, C> Encode for ArkScaleProjective<&'a Projective<C>>

where C: TECurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<'a, C> Encode for ArkScaleProjective<&'a Projective<C>>

where C: TECurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<'a, T, const U: u8> Encode for ArkScaleRef<'a, T, U>

where T: CanonicalSerialize,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<'a, T, const U: u8> Encode for ArkScaleRef<'a, T, U>

where T: CanonicalSerialize,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

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

where A0: Encode, B0: Encode, C0: Encode, D0: Encode, E0: Encode, F0: Encode, G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<AccountId, AccountIndex> Encode for MultiAddress<AccountId, AccountIndex>

where AccountId: Encode, AccountIndex: HasCompact,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<AccountId, Balance> Encode for Exposure<AccountId, Balance>

where Balance: HasCompact, Vec<IndividualExposure<AccountId, Balance>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<AccountId, Balance> Encode for ExposurePage<AccountId, Balance>

where Balance: HasCompact, Vec<IndividualExposure<AccountId, Balance>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<AccountId, Balance> Encode for IndividualExposure<AccountId, Balance>

where Balance: HasCompact, AccountId: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<Address, Call, Signature, Extension> Encode for UncheckedExtrinsic<Address, Call, Signature, Extension>

where Preamble<Address, Signature, Extension>: Encode, Call: Encode, Extension: Encode,

fn encode(&self) -> Vec<u8>

impl<Address, Signature, Extension> Encode for Preamble<Address, Signature, Extension>

where Address: Encode, Signature: Encode, Extension: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where B0: Encode, C0: Encode, D0: Encode, E0: Encode, F0: Encode, G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<B> Encode for BlockAndTimeDeadline<B>

where B: BlockNumberProvider, <B as BlockNumberProvider>::BlockNumber: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<Balance> Encode for PagedExposureMetadata<Balance>

where Balance: HasCompact + MaxEncodedLen,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<Block> Encode for BlockId<Block>

where Block: Block, <Block as Block>::Hash: Encode, <<Block as Block>::Header as Header>::Number: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<Block> Encode for SignedBlock<Block>

where Block: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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

where C0: Encode, D0: Encode, E0: Encode, F0: Encode, G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<C> Encode for ArkScaleProjective<Projective<C>>

where C: SWCurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<C> Encode for ArkScaleProjective<Projective<C>>

where C: SWCurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<C> Encode for ArkScaleProjective<Projective<C>>

where C: TECurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<C> Encode for ArkScaleProjective<Projective<C>>

where C: TECurveConfig,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<C> Encode for PublicKey<C>

where C: AffineRepr,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<C> Encode for VrfPreOut<C>

where C: AffineRepr,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<Call, Extension> Encode for SignedPayload<Call, Extension>

where Call: Encode + Dispatchable, Extension: TransactionExtension<Call>,

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Get an encoded version of this blake2_256-hashed payload.

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

where D0: Encode, E0: Encode, F0: Encode, G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where E0: Encode, F0: Encode, G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where F0: Encode, G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where G0: Encode, H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where H0: Encode, I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<H, L> Encode for MerkleProof<H, L>

where H: Encode, Vec<H>: Encode, L: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<Header, Extrinsic> Encode for Block<Header, Extrinsic>

where Header: Encode, Vec<Extrinsic>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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

where I0: Encode, J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<Info> Encode for DispatchErrorWithPostInfo<Info>

where Info: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<Inner> Encode for FakeDispatchable<Inner>

where Inner: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

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

where J0: Encode, K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where K0: Encode, L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<K, V> Encode for BTreeMap<K, V>

where K: Encode, V: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

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

where L0: Encode, M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where M0: Encode, N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

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

where N0: Encode, O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<Number, Hash> Encode for Header<Number, Hash>

where Number: Copy + Into<U256> + TryFrom<U256> + HasCompact, Hash: Hash, <Hash as Hash>::Output: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<O0, P0, Q0, R0> Encode for (O0, P0, Q0, R0)

where O0: Encode, P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<O, T> Encode for BitBox<T, O>

where O: BitOrder, T: BitStore + Encode,

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<O, T> Encode for BitSlice<T, O>

where O: BitOrder, T: BitStore + Encode,

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<O, T> Encode for BitVec<T, O>

where O: BitOrder, T: BitStore + Encode,

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<P0, Q0, R0> Encode for (P0, Q0, R0)

where P0: Encode, Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<P> Encode for VrfSignatureVec<P>

where P: EcVrfProof,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<P, const N: usize> Encode for VrfSignature<P, N>

where P: EcVrfProof,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<Q0, R0> Encode for (Q0, R0)

where Q0: Encode, R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

impl<R0> Encode for (R0,)

where R0: Encode,

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

impl<Reporter, Offender> Encode for OffenceDetails<Reporter, Offender>

where Offender: Encode, Vec<Reporter>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<SE> Encode for AsTransactionExtension<SE>

where SE: SignedExtension + Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for DeprecationInfoIR<T>

where T: Form, DeprecationStatusIR<T>: Encode, BTreeMap<Compact<u8>, DeprecationStatusIR<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for DeprecationStatusIR<T>

where T: Form, <T as Form>::String: Encode, Option<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for StorageEntryTypeIR<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for Option<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T> Encode for [T]

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T> Encode for Crossing<T>

where T: Encode + Decode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for ExtrinsicMetadataIR<T>

where T: Form, <T as Form>::Type: Encode, Vec<TransactionExtensionMetadataIR<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for OuterEnumsIR<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletAssociatedTypeMetadataIR<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletCallMetadataIR<T>

where T: Form, <T as Form>::Type: Encode, DeprecationInfoIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletConstantMetadataIR<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatusIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletErrorMetadataIR<T>

where T: Form, <T as Form>::Type: Encode, DeprecationInfoIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletEventMetadataIR<T>

where T: Form, <T as Form>::Type: Encode, DeprecationInfoIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletMetadataIR<T>

where T: Form, <T as Form>::String: Encode, Option<PalletStorageMetadataIR<T>>: Encode, Option<PalletCallMetadataIR<T>>: Encode, Option<PalletEventMetadataIR<T>>: Encode, Vec<PalletConstantMetadataIR<T>>: Encode, Option<PalletErrorMetadataIR<T>>: Encode, Vec<PalletAssociatedTypeMetadataIR<T>>: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatusIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletStorageMetadataIR<T>

where T: Form, <T as Form>::String: Encode, Vec<StorageEntryMetadataIR<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMetadataIR<T>

where T: Form, <T as Form>::String: Encode, Vec<RuntimeApiMethodMetadataIR<T>>: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatusIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMethodMetadataIR<T>

where T: Form, <T as Form>::String: Encode, Vec<RuntimeApiMethodParamMetadataIR<T>>: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatusIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMethodParamMetadataIR<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for StorageEntryMetadataIR<T>

where T: Form, <T as Form>::String: Encode, StorageEntryTypeIR<T>: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatusIR<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for TransactionExtensionMetadataIR<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for BinaryHeap<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T> Encode for BTreeSet<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T> Encode for LinkedList<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T> Encode for VecDeque<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T> Encode for Range<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode(&self) -> Vec<u8>

impl<T> Encode for RangeInclusive<T>

where T: Encode,

fn size_hint(&self) -> usize

fn encode(&self) -> Vec<u8>

impl<T> Encode for CustomMetadata<T>

where T: Form, BTreeMap<<T as Form>::String, CustomValueMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for CustomMetadata<T>

where T: Form, BTreeMap<<T as Form>::String, CustomValueMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for CustomValueMetadata<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for CustomValueMetadata<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for DeprecationInfo<T>

where T: Form, DeprecationStatus<T>: Encode, BTreeMap<u8, DeprecationStatus<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for DeprecationStatus<T>

where T: Form, <T as Form>::String: Encode, Option<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for ExtrinsicMetadata<T>

where T: Form, <T as Form>::Type: Encode, Vec<SignedExtensionMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for ExtrinsicMetadata<T>

where T: Form, <T as Form>::Type: Encode, Vec<SignedExtensionMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for ExtrinsicMetadata<T>

where T: Form, <T as Form>::Type: Encode, Vec<TransactionExtensionMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for Field<T>

where T: Form, Option<<T as Form>::String>: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for OuterEnums<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for OuterEnums<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletAssociatedTypeMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletCallMetadata<T>

where T: Form, <T as Form>::Type: Encode, DeprecationInfo<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletCallMetadata<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for PalletConstantMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatus<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletConstantMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletErrorMetadata<T>

where T: Form, <T as Form>::Type: Encode, DeprecationInfo<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletErrorMetadata<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for PalletEventMetadata<T>

where T: Form, <T as Form>::Type: Encode, DeprecationInfo<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletEventMetadata<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for PalletMetadata<T>

where T: Form, <T as Form>::String: Encode, Option<PalletStorageMetadata<T>>: Encode, Option<PalletCallMetadata<T>>: Encode, Option<PalletEventMetadata<T>>: Encode, Vec<PalletConstantMetadata<T>>: Encode, Option<PalletErrorMetadata<T>>: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletMetadata<T>

where T: Form, <T as Form>::String: Encode, Option<PalletStorageMetadata<T>>: Encode, Option<PalletCallMetadata<T>>: Encode, Option<PalletEventMetadata<T>>: Encode, Vec<PalletConstantMetadata<T>>: Encode, Option<PalletErrorMetadata<T>>: Encode, Vec<PalletAssociatedTypeMetadata<T>>: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatus<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletMetadata<T>

where T: Form, <T as Form>::String: Encode, Option<PalletStorageMetadata<T>>: Encode, Option<PalletCallMetadata<T>>: Encode, Option<PalletEventMetadata<T>>: Encode, Vec<PalletConstantMetadata<T>>: Encode, Option<PalletErrorMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletStorageMetadata<T>

where T: Form, <T as Form>::String: Encode, Vec<StorageEntryMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for PalletStorageMetadata<T>

where T: Form, <T as Form>::String: Encode, Vec<StorageEntryMetadata<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for Path<T>

where T: Form, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for RuntimeApiMetadata<T>

where T: Form, <T as Form>::String: Encode, Vec<RuntimeApiMethodMetadata<T>>: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatus<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMetadata<T>

where T: Form, <T as Form>::String: Encode, Vec<RuntimeApiMethodMetadata<T>>: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMethodMetadata<T>

where T: Form, <T as Form>::String: Encode, Vec<RuntimeApiMethodParamMetadata<T>>: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatus<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMethodMetadata<T>

where T: Form, <T as Form>::String: Encode, Vec<RuntimeApiMethodParamMetadata<T>>: Encode, <T as Form>::Type: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMethodParamMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for RuntimeApiMethodParamMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for SignedExtensionMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for SignedExtensionMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for StorageEntryMetadata<T>

where T: Form, <T as Form>::String: Encode, StorageEntryType<T>: Encode, Vec<<T as Form>::String>: Encode, DeprecationStatus<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for StorageEntryMetadata<T>

where T: Form, <T as Form>::String: Encode, StorageEntryType<T>: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for StorageEntryType<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for TransactionExtensionMetadata<T>

where T: Form, <T as Form>::String: Encode, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for Type<T>

where T: Form, Path<T>: Encode, Vec<TypeParameter<T>>: Encode, TypeDef<T>: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for TypeDef<T>

where T: Form, TypeDefComposite<T>: Encode, TypeDefVariant<T>: Encode, TypeDefSequence<T>: Encode, TypeDefArray<T>: Encode, TypeDefTuple<T>: Encode, TypeDefCompact<T>: Encode, TypeDefBitSequence<T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for TypeDefArray<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for TypeDefBitSequence<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for TypeDefCompact<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for TypeDefComposite<T>

where T: Form, Vec<Field<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for TypeDefSequence<T>

where T: Form, <T as Form>::Type: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for TypeDefTuple<T>

where T: Form, Vec<<T as Form>::Type>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for TypeDefVariant<T>

where T: Form, Vec<Variant<T>>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

fn encode(&self) -> Vec<u8>

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

impl<T> Encode for TypeParameter<T>

where T: Form, <T as Form>::String: Encode, Option<<T as Form>::Type>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for UntrackedSymbol<T>

where PhantomData<fn() -> T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T> Encode for Variant<T>

where T: Form, <T as Form>::String: Encode, Vec<Field<T>>: Encode, Vec<<T as Form>::String>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T, D> Encode for TypeWithDefault<T, D>

where D: Get<T>, T: Encode, PhantomData<D>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

impl<T, E> Encode for Result<T, E>

where T: Encode, E: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T, const L: usize> Encode for ArkScaleLen<T, L>

where T: CanonicalSerialize,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<T, const L: usize> Encode for ArkScaleLen<T, L>

where T: CanonicalSerialize,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

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

where T: Encode,

fn size_hint(&self) -> usize

fn encode_to<W>(&self, dest: &mut W)

where W: Output + ?Sized,

impl<T, const U: u8> Encode for ArkScale<T, U>

where T: CanonicalSerialize,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<T, const U: u8> Encode for ArkScale<T, U>

where T: CanonicalSerialize,

fn size_hint(&self) -> usize

fn encode_to<O>(&self, dest: &mut O)

where O: Output + ?Sized,

fn encoded_size(&self) -> usize

impl<Xt> Encode for Block<Xt>

where Vec<Xt>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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

fn encode(&self) -> Vec<u8>

impl<const N: usize, T> Encode for CryptoBytes<N, T>

where PhantomData<fn() -> T>: Encode,

fn size_hint(&self) -> usize

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

Implementors

impl Encode for DispatchClass

impl Encode for Pays

impl Encode for Never

impl Encode for SteppedMigrationError

impl Encode for VersionedPostUpgradeData

impl Encode for frame_support::storage::child::ChildInfo

impl Encode for KillStorageResult

impl Encode for frame_support::storage::child::StateVersion

impl Encode for ProcessMessageError

impl Encode for TrieError

impl Encode for Select

impl Encode for UpgradeCheckSelect

impl Encode for frame_support::traits::schedule::LookupError

impl Encode for BalanceStatus

impl Encode for PaymentStatus

impl Encode for frame_support::pallet_prelude::DispatchError

impl Encode for InvalidTransaction

impl Encode for TransactionSource

impl Encode for TransactionValidityError

impl Encode for UnknownTransaction

impl Encode for DispatchInfo

impl Encode for PostDispatchInfo

impl Encode for CheckInherentsResult

impl Encode for frame_support::storage::child::MultiRemovalResults

impl Encode for PalletId

impl Encode for CrateVersion

impl Encode for SixteenPatriciaMerkleTreeExistenceProof

impl Encode for StorageInfo

impl Encode for StorageVersion

impl Encode for frame_support::traits::TrackedStorageKey

impl Encode for WithdrawReasons

impl Encode for RuntimeDbWeight

impl Encode for InherentData

impl Encode for ValidTransaction

impl Encode for Weight

impl Encode for OptionBool

impl<'a> Encode for CompactRef<'a, u8>

impl<'a> Encode for CompactRef<'a, u16>

impl<'a> Encode for CompactRef<'a, u32>

impl<'a> Encode for CompactRef<'a, u64>

impl<'a> Encode for CompactRef<'a, u128>

impl<'a> Encode for CompactRef<'a, ()>

impl<'a, T> Encode for CompactRef<'a, T>

where T: CompactAs, CompactRef<'b, <T as CompactAs>::As>: for<'b> Encode,

impl<'a, T, S> Encode for BoundedSlice<'a, T, S>

where T: Encode, &'a [T]: Encode, PhantomData<S>: Encode,

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

where F: MutateFreeze<A>, F::Balance: Encode, PhantomData<fn() -> (A, R, D, Fp)>: Encode,

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

where F: MutateHold<A>, F::Balance: Encode, PhantomData<fn() -> (A, R, D, Fp)>: Encode,

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

where PhantomData<fn() -> (A, Fx, Rx, D, Fp)>: Encode,

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

where PhantomData<fn() -> (A, Fx, Rx, D, Fp)>: Encode,

impl<AccountId> Encode for RawOrigin<AccountId>

where AccountId: Encode,

impl<AssetId> Encode for NativeOrWithId<AssetId>

where AssetId: Ord + Encode,

impl<Balance> Encode for WeightToFeeCoefficient<Balance>

where Balance: Encode,

impl<BlockNumber> Encode for DispatchTime<BlockNumber>

where BlockNumber: Encode,

impl<E> Encode for MakeFatalError<E>

where E: Encode,

impl<Id, Balance> Encode for IdAmount<Id, Balance>

where Id: Encode, Balance: Encode,

impl<K, V, S> Encode for BoundedBTreeMap<K, V, S>

where BTreeMap<K, V>: Encode, PhantomData<S>: Encode,

impl<T> Encode for PerDispatchClass<T>

where T: Encode,

impl<T> Encode for PhantomData<T>

impl<T> Encode for Compact<T>

where CompactRef<'a, T>: for<'a> Encode,

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

where H::Output: Encode, PhantomData<T>: Encode,

impl<T, Hash> Encode for MaybeHashed<T, Hash>

where T: Encode, Hash: Encode,

impl<T, S> Encode for BoundedBTreeSet<T, S>

where BTreeSet<T>: Encode, PhantomData<S>: Encode,

impl<T, S> Encode for BoundedVec<T, S>

where Vec<T>: Encode, PhantomData<S>: Encode,

impl<T, S> Encode for WeakBoundedVec<T, S>

where Vec<T>: Encode, PhantomData<S>: Encode,

impl<T, X> Encode for X

where T: Encode + ?Sized, X: WrapperTypeEncode<Target = T>,

impl<T: Encode> Encode for WrapperKeepOpaque<T>

impl<T: Encode> Encode for WrapperOpaque<T>

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