Struct WithExtrinsicParams 

pub struct WithExtrinsicParams<T: Config, E: ExtrinsicParams<T::Index, T::Hash>> { /* private fields */ }

Helper struct for fast Config creation with different Extrinsic Params than the original Config.

Take a type implementing Config (eg AssetRuntimeConfig), and some type which describes the additional and extra parameters to pass to an extrinsic (see [ExtrinsicParams]), and returns a type implementing Config with those new [ExtrinsicParams].

Example

use ac_primitives::{ AssetRuntimeConfig, WithExtrinsicParams, PlainTipExtrinsicParams };

// This is how DefaultRuntimeConfig is implemented:
type DefaultRuntimeConfig = WithExtrinsicParams<AssetRuntimeConfig, PlainTipExtrinsicParams<AssetRuntimeConfig>>;

Trait Implementations

impl<T: Clone + Config, E: Clone + ExtrinsicParams<T::Index, T::Hash>> Clone for WithExtrinsicParams<T, E>

fn clone(&self) -> WithExtrinsicParams<T, E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Config, E: ExtrinsicParams<T::Index, T::Hash>> Config for WithExtrinsicParams<T, E>

type Index = <T as Config>::Index

Account index (aka nonce) type. This stores the number of previous transactions associated with a sender account. This type enforces the (de)serialization implementation also in no-std mode (unlike substrates MaybeSerializeDeserialize).

type BlockNumber = <T as Config>::BlockNumber

The block number type used by the runtime.

type Hash = <T as Config>::Hash

The output of the Hashing function.

type AccountId = <T as Config>::AccountId

The account ID type.

type Address = <T as Config>::Address

The address type.

type Signature = <T as Config>::Signature

The signature type.

type Hasher = <T as Config>::Hasher

The hashing system (algorithm) being used in the runtime (e.g. Blake2).

type Header = <T as Config>::Header

The block header.

type AccountData = <T as Config>::AccountData

The account data.

type ExtrinsicParams = E

This type defines the extrinsic extra and additional parameters.

type CryptoKey = <T as Config>::CryptoKey

The cryptographic PKI key pair type used to sign the extrinsic

type ExtrinsicSigner = ExtrinsicSigner<WithExtrinsicParams<T, E>>

This extrinsic signer.

type Block = <T as Config>::Block

The block type.

type Balance = <T as Config>::Balance

The balance type.

type ContractCurrency = <T as Config>::ContractCurrency

The currency type of the contract pallet.

type StakingBalance = <T as Config>::StakingBalance

The balance type of the staking pallet.

impl<T: Debug + Config, E: Debug + ExtrinsicParams<T::Index, T::Hash>> Debug for WithExtrinsicParams<T, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config, E: ExtrinsicParams<T::Index, T::Hash>> Decode for WithExtrinsicParams<T, E>

where PhantomData<(T, E)>: Decode,

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

Attempt to deserialise the value from input.

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

where I: Input,

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

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

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config, E: ExtrinsicParams<T::Index, T::Hash>> Encode for WithExtrinsicParams<T, E>

where PhantomData<(T, E)>: Encode,

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

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<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

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

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: PartialEq + Config, E: PartialEq + ExtrinsicParams<T::Index, T::Hash>> PartialEq for WithExtrinsicParams<T, E>

fn eq(&self, other: &WithExtrinsicParams<T, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Config, E: ExtrinsicParams<T::Index, T::Hash>> EncodeLike for WithExtrinsicParams<T, E>

where PhantomData<(T, E)>: Encode,

impl<T: Eq + Config, E: Eq + ExtrinsicParams<T::Index, T::Hash>> Eq for WithExtrinsicParams<T, E>

impl<T: Config, E: ExtrinsicParams<T::Index, T::Hash>> StructuralPartialEq for WithExtrinsicParams<T, E>