Struct xcm_calls::staking::StakingConfig[−][src]

pub struct StakingConfig<AccountId, Balance, BlockNumber> {
    pub pallet_index: u8,
    pub reward_destination: RewardDestination<AccountId>,
    pub minimum_balance: Balance,
    pub weights: StakingWeights,
    pub bonding_duration: BlockNumber,
    pub is_frozen: bool,
}

Expand description

The pallet_staking configuration for a particular chain

Fields

pallet_index: u8

The index of pallet_index within the parachain’s runtime

reward_destination: RewardDestination<AccountId>

The configured reward destination

minimum_balance: Balance

The specified minimum_balance specified the parachain’s T::Currency

weights: StakingWeights

The configured weights for pallet_staking

bonding_duration: BlockNumber

This measures the time that must pass until unbonded funds can be withdrawn measured in BlockNumbers

NOTE: It is expected that this is already the duration measured in PINT parachain blocks and NOT in remote chain blocks. This involves converting the block time of the other chain to the block time of PINT. The bonding_duration as it’s expected here is

   BondDuration * EPOCH_DURATION_IN_BLOCKS * SessionsPerEra * (MILLISEC_PER_BLOCK_other / MILLISEC_PER_BLOCK_pint)

is_frozen: bool

Whether the asset is frozen for xcm related transfers.

Struct xcm_calls::staking::StakingConfig[−][src]

Fields

Trait Implementations

impl<AccountId: Clone, Balance: Clone, BlockNumber: Clone> Clone for StakingConfig<AccountId, Balance, BlockNumber>

fn clone(&self) -> StakingConfig<AccountId, Balance, BlockNumber>

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

impl<AccountId, Balance, BlockNumber> Debug for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: Debug, Balance: Debug, BlockNumber: Debug,

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

impl<AccountId, Balance, BlockNumber> Decode for StakingConfig<AccountId, Balance, BlockNumber> where RewardDestination<AccountId>: Decode, RewardDestination<AccountId>: Decode, Balance: Decode, Balance: Decode, BlockNumber: Decode, BlockNumber: Decode,

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

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

fn encoded_fixed_size() -> Option<usize>

impl<'de, AccountId, Balance, BlockNumber> Deserialize<'de> for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: Deserialize<'de>, Balance: Deserialize<'de>, BlockNumber: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where __D: Deserializer<'de>,

impl<AccountId, Balance, BlockNumber> Encode for StakingConfig<AccountId, Balance, BlockNumber> where RewardDestination<AccountId>: Encode, RewardDestination<AccountId>: Encode, Balance: Encode, Balance: Encode, BlockNumber: Encode, BlockNumber: Encode,

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

fn size_hint(&self) -> usize

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

fn using_encoded<R, F>(&self, f: F) -> R where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<AccountId: PartialEq, Balance: PartialEq, BlockNumber: PartialEq> PartialEq<StakingConfig<AccountId, Balance, BlockNumber>> for StakingConfig<AccountId, Balance, BlockNumber>

fn eq(&self, other: &StakingConfig<AccountId, Balance, BlockNumber>) -> bool

fn ne(&self, other: &StakingConfig<AccountId, Balance, BlockNumber>) -> bool

impl<AccountId, Balance, BlockNumber> Serialize for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: Serialize, Balance: Serialize, BlockNumber: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where __S: Serializer,

type Identity = Self

fn type_info() -> Type

impl<AccountId: Eq, Balance: Eq, BlockNumber: Eq> Eq for StakingConfig<AccountId, Balance, BlockNumber>

impl<AccountId, Balance, BlockNumber> StructuralEq for StakingConfig<AccountId, Balance, BlockNumber>

impl<AccountId, Balance, BlockNumber> StructuralPartialEq for StakingConfig<AccountId, Balance, BlockNumber>

Auto Trait Implementations

impl<AccountId, Balance, BlockNumber> RefUnwindSafe for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: RefUnwindSafe, Balance: RefUnwindSafe, BlockNumber: RefUnwindSafe,

impl<AccountId, Balance, BlockNumber> Send for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: Send, Balance: Send, BlockNumber: Send,

impl<AccountId, Balance, BlockNumber> Sync for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: Sync, Balance: Sync, BlockNumber: Sync,

impl<AccountId, Balance, BlockNumber> Unpin for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: Unpin, Balance: Unpin, BlockNumber: Unpin,

impl<AccountId, Balance, BlockNumber> UnwindSafe for StakingConfig<AccountId, Balance, BlockNumber> where AccountId: UnwindSafe, Balance: UnwindSafe, BlockNumber: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

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

pub fn decode_all(input: &[u8]) -> Result<T, Error>

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

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>( limit: u32, input: &mut I) -> Result<T, Error> where I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

impl<T> Downcast for T where T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for T where T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<Q, K> Equivalent<K> for Q where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

pub fn equivalent(&self, key: &K) -> bool

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Hashable for T where T: Codec,

pub fn blake2_128(&self) -> [u8; 16]

impl<AccountId, Balance, BlockNumber> Debug for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: Debug,
Balance: Debug,
BlockNumber: Debug,

impl<AccountId, Balance, BlockNumber> Decode for StakingConfig<AccountId, Balance, BlockNumber> where
RewardDestination<AccountId>: Decode,
RewardDestination<AccountId>: Decode,
Balance: Decode,
Balance: Decode,
BlockNumber: Decode,
BlockNumber: Decode,

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

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

impl<'de, AccountId, Balance, BlockNumber> Deserialize<'de> for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: Deserialize<'de>,
Balance: Deserialize<'de>,
BlockNumber: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
__D: Deserializer<'de>,

impl<AccountId, Balance, BlockNumber> Encode for StakingConfig<AccountId, Balance, BlockNumber> where
RewardDestination<AccountId>: Encode,
RewardDestination<AccountId>: Encode,
Balance: Encode,
Balance: Encode,
BlockNumber: Encode,
BlockNumber: Encode,

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

fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8 ]) -> R,

impl<AccountId, Balance, BlockNumber> Serialize for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: Serialize,
Balance: Serialize,
BlockNumber: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,

impl<AccountId, Balance, BlockNumber> RefUnwindSafe for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: RefUnwindSafe,
Balance: RefUnwindSafe,
BlockNumber: RefUnwindSafe,

impl<AccountId, Balance, BlockNumber> Send for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: Send,
Balance: Send,
BlockNumber: Send,

impl<AccountId, Balance, BlockNumber> Sync for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: Sync,
Balance: Sync,
BlockNumber: Sync,

impl<AccountId, Balance, BlockNumber> Unpin for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: Unpin,
Balance: Unpin,
BlockNumber: Unpin,

impl<AccountId, Balance, BlockNumber> UnwindSafe for StakingConfig<AccountId, Balance, BlockNumber> where
AccountId: UnwindSafe,
Balance: UnwindSafe,
BlockNumber: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

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

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

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

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn saturated_from<T>(t: T) -> Self where
Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> T where
Self: UniqueSaturatedInto<T>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,