Struct WithAddress 

pub struct WithAddress<T, A>
where
    T: Config,
    A: Debug + Clone + Encode + From<T::AccountId>,
{ /* private fields */ }

Changes the Address type of the underlying Runtime Config. This allows to change the type of the Config without having to define all the other types as well.

Example

use ac_primitives::{ DefaultRuntimeConfig, WithAddress, MultiAddress, AccountId32 };

type RococoRuntimeConfig = WithAddress<DefaultRuntimeConfig, MultiAddress<AccountId32, ()>>;

Trait Implementations

impl<T, A> Clone for WithAddress<T, A>

where T: Config + Clone, A: Debug + Clone + Encode + From<T::AccountId> + Clone,

fn clone(&self) -> WithAddress<T, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, A> Config for WithAddress<T, A>

where T: Config, A: Debug + Clone + Encode + From<T::AccountId>,

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 = A

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 = <T as Config>::ExtrinsicParams

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<WithAddress<T, A>>

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, A> Debug for WithAddress<T, A>

where T: Config + Debug, A: Debug + Clone + Encode + From<T::AccountId> + Debug,

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

Formats the value using the given formatter.

impl<T, A> Decode for WithAddress<T, A>

where T: Config, A: Debug + Clone + Encode + From<T::AccountId>, PhantomData<(T, A)>: 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, A> Encode for WithAddress<T, A>

where T: Config, A: Debug + Clone + Encode + From<T::AccountId>, PhantomData<(T, A)>: 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, A> PartialEq for WithAddress<T, A>

where T: Config + PartialEq, A: Debug + Clone + Encode + From<T::AccountId> + PartialEq,

fn eq(&self, other: &WithAddress<T, A>) -> 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, A> EncodeLike for WithAddress<T, A>

where T: Config, A: Debug + Clone + Encode + From<T::AccountId>, PhantomData<(T, A)>: Encode,

impl<T, A> Eq for WithAddress<T, A>

where T: Config + Eq, A: Debug + Clone + Encode + From<T::AccountId> + Eq,

impl<T, A> StructuralPartialEq for WithAddress<T, A>

where T: Config, A: Debug + Clone + Encode + From<T::AccountId>,