Struct Delegate

pub struct Delegate {
    pub validator_identity: IdentityKey,
    pub epoch_index: u64,
    pub unbonded_amount: Amount,
    pub delegation_amount: Amount,
}

A transaction action adding stake to a validator’s delegation pool.

Fields

validator_identity: IdentityKey

The identity key of the validator to delegate to.

epoch_index: u64

The index of the epoch in which this delegation was performed. The delegation takes effect in the next epoch.

unbonded_amount: Amount

The delegation amount, in units of unbonded stake. TODO: use flow aggregation to hide this, replacing it with bytes amount_ciphertext;

delegation_amount: Amount

The amount of delegation tokens produced by this action.

This is implied by the validator’s exchange rate in the specified epoch (and should be checked in transaction validation!), but including it allows stateless verification that the transaction is internally consistent.

Implementations

impl Delegate

pub fn balance(&self) -> Balance

Return the balance resulting from issuing delegation tokens from staking tokens.

pub fn delegation_value(&self) -> Value

Returns the Value of the delegation Amount.

pub fn unbonded_value(&self) -> Value

Returns the Value of the unbonded Amount.

Trait Implementations

impl ActionHandler for Delegate

Available on crate feature component only.

type CheckStatelessContext = ()

Context for stateless validity checks, like the transaction containing the action.

fn check_stateless<'life0, 'async_trait>( &'life0 self, _context: (), ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Performs all of this action’s stateless validity checks in the context of some [Transaction].

fn check_and_execute<'life0, 'async_trait, S>( &'life0 self, state: S, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where S: 'async_trait + StateWrite, Self: 'async_trait, 'life0: 'async_trait,

Attempts to execute this action against the provided state.

fn check_historical<'life0, 'async_trait, S>( &'life0 self, _state: Arc<S>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, S: 'async_trait + StateRead + 'static, Self: Sync + 'async_trait,

Performs those stateful validity checks that can be performed against a historical state snapshot.

impl Clone for Delegate

fn clone(&self) -> Delegate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Delegate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Delegate

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DomainType for Delegate

type Proto = Delegate

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

Encode this domain type to a byte vector, via proto type P.

fn to_proto(&self) -> Self::Proto

Convert this domain type to the associated proto type.

fn decode<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Decode this domain type from a byte buffer, via proto type P.

impl EffectingData for Delegate

fn effect_hash(&self) -> EffectHash

impl From<&Delegate> for EventDelegate

fn from(value: &Delegate) -> Self

Converts to this type from the input type.

impl From<Delegate> for Delegate

fn from(d: Delegate) -> Self

Converts to this type from the input type.

impl Serialize for Delegate

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Delegate> for Delegate

type Error = Error

The type returned in the event of a conversion error.

fn try_from(d: Delegate) -> Result<Self, Self::Error>

Performs the conversion.