Struct Staking 

pub struct Staking {
    pub certificates: Vec<Certificate>,
    pub withdrawal: Option<(Vec<u8>, u64)>,
    pub votes: Option<(Hash<28>, Vec<(GovActionId, Vote)>)>,
}

What an account transaction does with the stake key and the DRep key besides paying: certificates, a reward withdrawal, and votes. Empty for a plain payment.

Fields

certificates: Vec<Certificate>

withdrawal: Option<(Vec<u8>, u64)>

The reward account (its address bytes) and the rewards withdrawn.

votes: Option<(Hash<28>, Vec<(GovActionId, Vote)>)>

Votes cast by the account’s DRep: its key hash, and each governance action’s vote.

Implementations

impl Staking

pub fn none() -> Self

Nothing: a plain payment.

pub fn withdraw(key: &StakeKey, state: &StakeState) -> Result<Self>

The whole reward balance, withdrawn alongside a payment: nothing when there are no rewards. Refused when the vote isn’t delegated.

pub fn of( key: &StakeKey, action: &StakeAction, state: &StakeState, key_deposit: u64, ) -> Result<Self>

The certificates and withdrawal action needs, the key standing as state says. key_deposit is the current protocol parameter, paid when the key is registered.

pub fn drep( stake: &StakeKey, stake_state: &StakeState, drep: &DrepKey, drep_state: &DrepState, action: &DrepAction, params: &ProtocolParameters, ) -> Result<Self>

The certificates and votes action needs, the DRep standing as drep_state says and the stake key as stake_state does. Registering pays params’ drep_deposit, and key_deposit too when the vote delegation must register the stake key.

pub fn is_empty(&self) -> bool

pub fn stake_signs(&self) -> bool

Whether the stake key signs: for a stake certificate or a withdrawal.

pub fn drep_signs(&self) -> bool

Whether the DRep key signs: for a DRep certificate or a vote.

pub fn signers(&self) -> usize

How many keys sign besides the payment keys: the stake key, the DRep key, or both.

pub fn deposit(&self) -> u64

Lovelace the certificates lock up: a registration’s deposit.

pub fn drep_deposit(&self) -> u64

Of Self::deposit, what registering a DRep locks up: it comes back when the DRep retires, not when the stake key does.

pub fn refund(&self) -> u64

Lovelace the certificates return: an unregistration’s deposit.

pub fn withdrawn(&self) -> u64

Rewards withdrawn.

pub fn net(&self, inputs: u64) -> Option<u64>

What the inputs gain (rewards, a refund) less what they lose (a deposit), for the transaction’s balance; None below zero.

pub fn patch(&self, built: BuiltTransaction) -> Result<BuiltTransaction>

Sets the certificates and withdrawal in built, an unsigned transaction, and returns it with its new hash. Nothing to set leaves it as it was.

Trait Implementations

impl Clone for Staking

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Staking

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

Formats the value using the given formatter.

impl Default for Staking

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Staking

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Staking