Struct penumbra_stake::undelegate::Undelegate

pub struct Undelegate {
    pub validator_identity: IdentityKey,
    pub from_epoch: Epoch,
    pub unbonded_amount: Amount,
    pub delegation_amount: Amount,
}

A transaction action withdrawing stake from a validator’s delegation pool.

Fields

validator_identity: IdentityKey

The identity key of the validator to undelegate from.

from_epoch: Epoch

The epoch at which the undelegation was performed. The undelegation takes effect after the unbonding period.

unbonded_amount: Amount

The amount to undelegate, in units of unbonding tokens.

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 Undelegate

pub fn balance(&self) -> Balance

Return the balance after consuming delegation tokens, and producing unbonding tokens.

pub fn unbonding_token(&self) -> UnbondingToken

pub fn unbonded_value(&self) -> Value

Returns the Value of the unbonded Amount.

pub fn delegation_token(&self) -> DelegationToken

pub fn delegation_value(&self) -> Value

Returns the Value of the delegation Amount.

Trait Implementations

impl ActionHandler for Undelegate

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 Undelegate

fn clone(&self) -> Undelegate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Undelegate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Undelegate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DomainType for Undelegate

type Proto = Undelegate

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 Undelegate

fn effect_hash(&self) -> EffectHash

impl From<Undelegate> for Undelegate

fn from(d: Undelegate) -> Self

Converts to this type from the input type.

impl PartialEq for Undelegate

fn eq(&self, other: &Undelegate) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Undelegate

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Undelegate> for Undelegate

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for Undelegate

impl StructuralPartialEq for Undelegate