Struct StakeData 

pub struct StakeData {
    pub amount: Option<(u64, BlockHeight)>,
    pub reward: u64,
    pub counter: u64,
}

The representation of a public key’s stake.

A user can stake for a particular amount larger in value than the MINIMUM_STAKE value and is rewarded for participating in the consensus. A stake is valid only after a particular block height - called the eligibility.

To keep track of the number of interactions a public key has had with the contract a counter is used to prevent repeat attacks - where the same signature could be used to prove ownership of the secret key in two different transactions.

Fields

amount: Option<(u64, BlockHeight)>

Amount staked and eligibility.

reward: u64

The reward for participating in consensus.

counter: u64

The signature counter to prevent replay.

Implementations

impl StakeData

pub const fn new(value: u64, reward: u64, block_height: BlockHeight) -> Self

Create a new stake given its initial value and reward, together with the block_height of its creation.

pub const fn with_eligibility( value: u64, reward: u64, eligibility: BlockHeight, ) -> Self

Create a new stake given its initial value and reward, together with the eligibility.

pub const fn amount(&self) -> Option<&(u64, BlockHeight)>

Returns the value the user is staking, together with its eligibility.

pub const fn reward(&self) -> u64

Returns the value of the reward.

pub const fn counter(&self) -> u64

Returns the interaction count of the stake.

pub fn insert_amount(&mut self, value: u64, block_height: BlockHeight)

Insert a stake [amount] with a particular value, starting from a particular block_height.

Panics

If the value is zero or the stake already contains an amount.

pub fn increase_reward(&mut self, value: u64)

Increases the held reward by the given value.

pub fn remove_amount(&mut self) -> (u64, BlockHeight)

Removes the total [amount] staked.

Panics

If the stake has no amount.

pub fn deplete_reward(&mut self)

Sets the reward to zero.

pub fn increment_counter(&mut self)

Increment the interaction [counter].

pub fn is_valid(&self, block_height: BlockHeight) -> bool

Returns true if the stake is valid - meaning there is an amount staked and the given block_height is larger or equal to the stake’s eligibility. If there is no amount staked this is false.

pub const fn eligibility_from_height(block_height: BlockHeight) -> u64

Compute the eligibility of a stake from the starting block height.

Trait Implementations

impl Archive for StakeData

where Option<(u64, BlockHeight)>: Archive, u64: Archive,

type Archived = ArchivedStakeData

The archived representation of this type.

type Resolver = StakeDataResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for StakeData

fn clone(&self) -> StakeData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StakeData

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

Formats the value using the given formatter.

impl Default for StakeData

fn default() -> StakeData

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized> Deserialize<StakeData, __D> for Archived<StakeData>

where Option<(u64, BlockHeight)>: Archive, Archived<Option<(u64, BlockHeight)>>: Deserialize<Option<(u64, BlockHeight)>, __D>, u64: Archive, Archived<u64>: Deserialize<u64, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<StakeData, __D::Error>

Deserializes using the given deserializer

impl PartialEq for StakeData

fn eq(&self, other: &StakeData) -> 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<__S: Fallible + ?Sized> Serialize<__S> for StakeData

where Option<(u64, BlockHeight)>: Serialize<__S>, u64: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for StakeData

impl StructuralPartialEq for StakeData